Executors.newFixedThreadPool和ArrayBlockingQueue一点使用心得

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

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

newFixedThreadPool使用范例：

Java代码

1. importjava.io.IOException;
2. importjava.util.concurrent.ExecutorService;
3. importjava.util.concurrent.Executors;
5. publicclassTest{
7. publicstaticvoidmain(String[]args)throwsIOException,InterruptedException{
8. ExecutorServiceservice=Executors.newFixedThreadPool(2);
9. for(inti=0;i<6;i++){
10. finalintindex=i;
11. System.out.println("task:"+(i+1));
12. Runnablerun=newRunnable(){
13. @Override
14. publicvoidrun(){
15. System.out.println("threadstart"+index);
16. try{
17. Thread.sleep(Long.MAX_VALUE);
18. }catch(InterruptedExceptione){
19. e.printStackTrace();
20. }
21. System.out.println("threadend"+index);
22. }
23. };
24. service.execute(run);
25. }
26. }
27. }

输出：

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. importjava.io.IOException;
2. importjava.util.concurrent.ArrayBlockingQueue;
3. importjava.util.concurrent.BlockingQueue;
4. importjava.util.concurrent.ThreadPoolExecutor;
5. importjava.util.concurrent.TimeUnit;
7. publicclassTest{
9. publicstaticvoidmain(String[]args)throwsIOException,InterruptedException{
11. BlockingQueue<Runnable>queue=newArrayBlockingQueue<Runnable>(3);
13. ThreadPoolExecutorexecutor=newThreadPoolExecutor(3,3,1,TimeUnit.HOURS,queue,newThreadPoolExecutor.CallerRunsPolicy());
15. for(inti=0;i<10;i++){
16. finalintindex=i;
17. System.out.println("task:"+(index+1));
18. Runnablerun=newRunnable(){
19. @Override
20. publicvoidrun(){
21. System.out.println("threadstart"+(index+1));
22. try{
23. Thread.sleep(Long.MAX_VALUE);
24. }catch(InterruptedExceptione){
25. e.printStackTrace();
26. }
27. System.out.println("threadend"+(index+1));
28. }
29. };
30. executor.execute(run);
31. }
32. }
33. }

输出：

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了。