http://heipark.iteye.com/blog/1393847

newFixedThreadPool内部有个任务队列,假设线程池里有3个线程,提交了5个任务,那么后两个任务就放在任务队列了,即使前3个任务sleep或者堵塞了,也不会执行后两个任务,除非前三个任务有执行完的newFixedThreadPool使用范例: 

Java代码  收藏代码

  1. import java.io.IOException;  

  2. import java.util.concurrent.ExecutorService;  

  3. import java.util.concurrent.Executors;  

  4.   

  5. public class Test {   

  6.     public static void main(String[] args) throws IOException, InterruptedException {  

  7.         ExecutorService service = Executors.newFixedThreadPool(2);  

  8.         for (int i = 0; i < 6; i++) {  

  9.             final int index = i;  

  10.             System.out.println("task: " + (i+1));  

  11.             Runnable run = new Runnable() {  

  12.                 @Override  

  13.                 public void run() {  

  14.                     System.out.println("thread start" + index);  

  15.                     try {  

  16.                         Thread.sleep(Long.MAX_VALUE);  

  17.                     } catch (InterruptedException e) {  

  18.                         e.printStackTrace();  

  19.                     }  

  20.                     System.out.println("thread end" + index);  

  21.                 }  

  22.             };  

  23.             service.execute(run);  

  24.         }  

  25.     }  

  26. }  

 

 输出:

task: 1
task: 2
thread start0
task: 3
task: 4
task: 5
task: 6
task: 7
thread start1
task: 8
task: 9
task: 10
task: 11
task: 12
task: 13
task: 14
task: 15

 

    从实例可以看到for循环并没有被固定的线程池阻塞住,也就是说所有的线程task都被提交到了ExecutorService中,查看 Executors.newFixedThreadPool()如下:

 

public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}

    可以看到task被提交都了LinkedBlockingQueue中。这里有个问题,如果任务列表很大,一定会把内存撑爆,如何解决?看下面: 

Java代码  收藏代码

  1. import java.io.IOException;  

  2. import java.util.concurrent.ArrayBlockingQueue;  

  3. import java.util.concurrent.BlockingQueue;  

  4. import java.util.concurrent.ThreadPoolExecutor;  

  5. import java.util.concurrent.TimeUnit;  

  6.   

  7. public class Test {    

  8.     public static void main(String[] args) throws IOException, InterruptedException {  

  9.           

  10.         BlockingQueue<Runnable> queue = new ArrayBlockingQueue<Runnable>(3);          

  11.         ThreadPoolExecutor executor = new ThreadPoolExecutor(331, TimeUnit.HOURS, queue, new ThreadPoolExecutor.CallerRunsPolicy());            

  12.         for (int i = 0; i < 10; i++) {  

  13.             final int index = i;  

  14.             System.out.println("task: " + (index+1));  

  15.             Runnable run = new Runnable() {  

  16.                 @Override  

  17.                 public void run() {  

  18.                     System.out.println("thread start" + (index+1));  

  19.                     try {  

  20.                         Thread.sleep(Long.MAX_VALUE);  

  21.                     } catch (InterruptedException e) {  

  22.                         e.printStackTrace();  

  23.                     }  

  24.                     System.out.println("thread end" + (index+1));  

  25.                 }  

  26.             };  

  27.             executor.execute(run);  

  28.         }  

  29.     }  

  30. }  

 

 输出:

task: 1
task: 2
thread start1
task: 3
task: 4
task: 5
task: 6
task: 7
thread start2
thread start7
thread start6

 

    线程池最大值为4(??这里我不明白为什么是设置值+1,即3+1,而不是3),准备执行的任务队列为3。可以看到for循环先处理4个task,然后把3个放到队列。这样就实现了自动阻塞队列的效果。记得要使用ArrayBlockingQueue这个队列,然后设置容量就OK了。