Executors.newFixedThreadPool和ArrayBlockingQueue一点使用心得

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

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

newFixedThreadPool使用范例：

 

 

 

Java代码  

import java.io.IOException;  

import java.util.concurrent.ExecutorService;  

import java.util.concurrent.Executors;  

  

public class Test {  

  

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

        ExecutorService service = Executors.newFixedThreadPool(2);  

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

            final int index = i;  

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

            Runnable run = new Runnable() {  

                @Override  

                public void run() {  

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

                    try {  

                        Thread.sleep(Long.MAX_VALUE);  

                    } catch (InterruptedException e) {  

                        e.printStackTrace();  

                    }  

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

                }  

            };  

            service.execute(run);  

        }  

    }  

}  

 

输出： 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代码  

import java.io.IOException;  

import java.util.concurrent.ArrayBlockingQueue;  

import java.util.concurrent.BlockingQueue;  

import java.util.concurrent.ThreadPoolExecutor;  

import java.util.concurrent.TimeUnit;  

  

public class Test {  

  

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

          

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

          

        ThreadPoolExecutor executor = new ThreadPoolExecutor(3, 3, 1, TimeUnit.HOURS, queue, new ThreadPoolExecutor.CallerRunsPolicy());  

          

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

            final int index = i;  

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

            Runnable run = new Runnable() {  

                @Override  

                public void run() {  

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

                    try {  

                        Thread.sleep(Long.MAX_VALUE);  

                    } catch (InterruptedException e) {  

                        e.printStackTrace();  

                    }  

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

                }  

            };  

            executor.execute(run);  

        }  

    }  

}  

 

输出： 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了。

总结

以上是生活随笔为你收集整理的Executors.newFixedThreadPool和ArrayBlockingQueue一点使用心得的全部内容，希望文章能够帮你解决所遇到的问题。

如果觉得生活随笔网站内容还不错，欢迎将生活随笔推荐给好友。