之前在阅读《Java并发编程的艺术》一书中看到了其中介绍了有关Java线程池的技术，为了加深自己的理解，我打算通过书中的一个简单的线程池实例来强化一下。
在服务端编程时，我们常常会碰到短时间并且大量的请求，在一般的情况下，我们会对每一个请求都创建一个线程进行处理，然后处理完请求后再关闭线程。这样看似没有问题，但是假如对每一个任务都创建一个线程去处理，假如创建的线程很多，系统就会频繁地进行上下文切换，这样就会加大系统的负载。
线程池技术应对上述问题的做法是这样的：创建一组固定数量的线程构成一个线程池，将客户端的请求放到请求队列中，然后启动线程池的线程，其中的线程就会去请求队列获取需要被执行的任务，问题的关键是在执行完任务之后，线程并不被关闭，而是继续从请求队列获取任务并执行，如果请求队列没有任务等待被执行，那么该线程就处于等待的状态。线程池的好处是可以减少后续创建线程的开销，并能使得系统在固定线程的情况下稳定地工作，我下面使用一个例子来进行一下说明
先定义一个线程池的接口，里面包含线程池的基本操作，如下所示：
public interface ThreadPool {
//执行一个Job,这个Job需要实现Runnabale
public void execute(Job job);
//关闭线程池
public void shutdown();
//添加工作线程
public void addWorkers(int num);
//移除工作线程
public void removeWorkers(int num);
//得到正在等待执行的任务数量
public int getSize();
}
从上面可以看到，一个线程池接口包含的功能为
- 将任务添加到任务队列等待被执行的方法
execute(Job job) - 增加和删除线程池中的线程数方法
addWorkers(int num)和removeWorkers(int num) - 关闭线程池中的所有线程方法
shutdown() - 获取任务队列中的任务数方法
getSize()
针对这个线程池的接口，我们来对它进行实现如下:
public class DefaultThreadPool implements ThreadPool {
//设置工作者数量上限
private static final int MAX_WORKER_NUMBERS = 10;
//默认的工作者数量
private static final int DEFAULT_WORKER_NUMBERS = 5;
//设置工作者数量下限
private static final int MIN_WORKER_NUMBER = 1;
//接收的任务队列
private final LinkedList jobs = new LinkedList();
//工作者
private final List workers = Collections.synchronizedList(new ArrayList());
//工作者线程的数量
private int workerNum = DEFAULT_WORKER_NUMBERS;
//线程编号
private AtomicInteger threadnum = new AtomicInteger();
public DefaultThreadPool(){
initializeWorkers(DEFAULT_WORKER_NUMBERS);
}
//创建线程池中的线程数
public DefaultThreadPool(int num){
int workernum = num > MAX_WORKER_NUMBERS ? MAX_WORKER_NUMBERS : num < MIN_WORKER_NUMBER ? MIN_WORKER_NUMBER : num;
initializeWorkers(workernum);
}
//将任务添加到任务队列中，假如线程池中有空闲的线程，那么该空闲的线程就会执行任务队列里的任务
@Override
public void execute(Job job) {
if(job != null){
synchronized (jobs){
jobs.addLast(job);
jobs.notify();
}
}
}
//关闭线程池中的所有线程
@Override
public void shutdown() {
for(Worker worker : workers)
worker.shutdown();
}
//增加线程池中的线程数
@Override
public void addWorkers(int num) {
synchronized (jobs){
if(num + this.workerNum > MAX_WORKER_NUMBERS)
num = MAX_WORKER_NUMBERS - this.workerNum;
initializeWorkers(num);
this.workerNum += num;
}
}
//移除线程池中特定数目的线程
@Override
public void removeWorkers(int num) {
synchronized (jobs){
if(num >= this.workerNum)
throw new IllegalArgumentException("beyond workerNum");
int count = 0;
while (count < num){
Worker worker = workers.get(count);
if(workers.remove(worker)){
worker.shutdown();
count++;
}
}
this.workerNum -= count;
}
}
//获取任务队列的大小
@Override
public int getSize() {
return jobs.size();
}
//根据要求创建的线程数创建一个特定大小的线程池，并启动线程池中的所有线程
public void initializeWorkers(int num){
for(int i = 0;i < num;i++){
Worker worker = new Worker();
workers.add(worker);
Thread thread = new Thread(worker,"Thread-num-" + threadnum.incrementAndGet());
thread.start();
}
}
class Worker implements Runnable{
private volatile boolean running = true;
@Override
public void run() {
while (running){
Job job = null;
synchronized (jobs){
while (jobs.isEmpty()){
try {
jobs.wait();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
return;
}
}
job = jobs.removeFirst();
}
if(job != null){
job.run();
}
}
}
public void shutdown(){
running = false;
}
}
}
下述是启动代码:
public class ThreadPoolTest {
public static void main(String[] args){
//创建一个线程规模为8的线程池并启动线程池中的所有线程
DefaultThreadPool pool = new DefaultThreadPool(8);
pool.execute(new Job());
}
}
针对上述代码，我们做一下分析:
- 开始启动的时候，程序调用类
DefaultThreadPool中的DefaultThreadPool(int num)方法来创建线程个数为8的线程池，并启动所有的线程 - 被启动的线程获取等待队列
jobs的锁并进入同步队列的循环之中，此时假设jobs任务队列还没有被添加任何任务，那么线程便会执行到jobs.wait()这一行，进入休眠状态(实际上是被放到了休眠的队列)并释放已获得的jobs的锁以便让其他的被阻塞在同步块synchronized (jobs){这里的线程获取锁并进入同步块，但是其它的线程很快发现自己和第一个获取锁的线程所面对的状况一样，那么其它线程会自动地添加到正在休眠的线程队列后面 - 终于，有一个任务通过调用
pool.execute(new Job())被添加到了任务队列之中，这个任务首先通过获取jobs的锁，并把新任务放到jobs队列之中，然后通过调用jobs.notify()来唤醒睡眠队列中因为任务队列jobs为空而被阻塞的第一个线程 - 所有没有被阻塞的线程现在竞争任务队列中任务，假如任务队列中一直存在任务，那么这些工作线程在处理完所有的请求后会再度进入睡眠的队列