Question

java，一个程序建立1000个线程，每一个线程加1到一个变量sum。

Answer 1

1、程序建立1000个线程，有可能造成系统创建大量线程而导致消耗完系统内存，还会增加创建和销毁线程上所花的时间以及系统资源的开销 

2、在创建线程数多的情况下，可以考虑使用线程池

以下是Java自带的几种线程池：

（1）、newFixedThreadPool 创建一个指定工作线程数量的线程池。

每当提交一个任务就创建一个工作线程，如果工作线程数量达到线程池初始的最大数，则将提交的任务存入到池队列中。

（2）、newCachedThreadPool 创建一个可缓存的线程池。

这种类型的线程池特点是：

1).工作线程的创建数量几乎没有限制(其实也有限制的,数目为Interger. MAX_VALUE), 这样可灵活的往线程池中添加线程。

2).如果长时间没有往线程池中提交任务，即如果工作线程空闲了指定的时间(默认为1分钟)，则该工作线程将自动终止。终止后，如果你又提交了新的任务，则线程池重新创建一个工作线程。

（3）、newSingleThreadExecutor 创建一个单线程化的Executor，即只创建唯一的工作者线程来执行任务，如果这个线程异常结束，会有另一个取代它，保证顺序执行(我觉得这点是它的特色)。

单工作线程最大的特点是可保证顺序地执行各个任务，并且在任意给定的时间不会有多个线程是活动的 。

（4）、newScheduleThreadPool 创建一个定长的线程池，而且支持定时的以及周期性的任务执行，类似于Timer。

3、示例代码

package test;  
import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
public class ThreadPoolExecutorTest {  
 public static void main(String[] args) {  
  ExecutorService cachedThreadPool = Executors.newCachedThreadPool();  
  for (int i = 0; i < 1000; i++) {  
   
   cachedThreadPool.execute(new Runnable() {  
    public void run() {  
         //在这里执行你需要的功能
    }  
   });  
  }  
 }  
}

Answer 2

package com.company;
class Adder {
    private int sum;
    public Adder() { sum = 0; }
    public void addOne() { sum += 1; }
    public int getSum() { return sum; }
}
class AddThread extends Thread {
    private Adder adder;
    public AddThread(Adder a) {
        adder = a;
    }
    public void run() {
        synchronized (adder) {
            adder.addOne();
        }
    }
}
public class Main {
    public static void main(String[] args) {
        Adder a = new Adder();
        Thread[] threads = new Thread[1000];
        for (int i = 0; i < 1000; i++) {
            threads[i] = new AddThread(a);
        }
        for (int i = 0; i < 1000; i++) {
            threads[i].start();
        }
        try {
            for (int i = 0; i < 1000; i++) {
                threads[i].join();
            }
        } catch (InterruptedException e) {
        }
        System.out.println("Sum = " + a.getSum());
    }
}

追问

代码有点问题啊

亲

追答

"代码有点问题啊" - 什么问题？请给出具体的错误。

Answer 3

import java.util.ArrayList;
import java.util.List;
import java.io.IOException;
class SumObj{
	int sum;
	public SumObj(){
		sum=0;
	}
	public synchronized void addNumToSum(int n){
		sum+=n;
	}
	public synchronized int getSum(){
		return this.sum;
	}
}
class AddThread implements Runnable{
	private SumObj sumObj;
	
	public AddThread(SumObj sumObj){
		this.sumObj=sumObj;
	}
	
	@Override
	public void run() {
		this.sumObj.addNumToSum(1);
		System.out.println(Thread.currentThread().getName()+" finish add number!");
	}
}
public class Test {

	public static void main(String[] args) throws IOException {
		List<Runnable>threads=new ArrayList<Runnable>();
		SumObj sumObj=new SumObj();
		for(int i=0;i<1000;i++){
			threads.add(new AddThread(sumObj));
		}
		//开启线程
		for(Runnable r:threads){
			new Thread(r).start();
		}
		while(sumObj.getSum()<1000){
			try {
				Thread.currentThread().sleep(1);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		System.out.println("sum : "+sumObj.getSum());
		
	}

}

Answer 4

那就new 1000个线程呗 。。。