Executors.newFixedThreadPool和ArrayBlockingQueue一点使用心得

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