Java多线程：新特性—线程池

概念

线程池的基本思想还是一种对象池的思想，开辟一块内存空间，里面存放了众多（未死亡）的线程，池中线程执行调度由池管理器来处理。

当有线程任务时，从池中取一个，执行完成后线程对象归池，这样可以避免反复创建线程对象所带来的性能开销，节省了系统的资源。

Java5的线程池分好多种：固定尺寸的线程池、可变尺寸连接池、当然你还可以自定义线程池。

在使用线程池之前，必须知道如何去创建一个线程池，在Java5中，需要了解的是java.util.concurrent.Executors类的API，这个类提供大量创建连接池的静态方法，是必须掌握的。

固定大小的线程池

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
import java.util.concurrent.Executors; 
import java.util.concurrent.ExecutorService; 
/** 
* 固定大小的线程池
* 
*/ 
public class Test { 
        public static void main(String[] args) { 
                //创建一个可重用固定线程数的线程池 
                ExecutorService pool = Executors.newFixedThreadPool(2); 
                //创建实现了Runnable接口对象，Thread对象当然也实现了Runnable接口 
                Thread t1 = new MyThread(); 
                Thread t2 = new MyThread(); 
                Thread t3 = new MyThread(); 
                Thread t4 = new MyThread(); 
                Thread t5 = new MyThread(); 
                //将线程放入池中进行执行 
                pool.execute(t1); 
                pool.execute(t2); 
                pool.execute(t3); 
                pool.execute(t4); 
                pool.execute(t5); 
                //关闭线程池 
                pool.shutdown(); 
        } 
} 
class MyThread extends Thread{ 
        @Override 
        public void run() { 
                System.out.println(Thread.currentThread().getName()+"正在执行..."); 
        } 
}

输出结果:

1
2
3
4
5
pool-1-thread-1正在执行...
pool-1-thread-2正在执行...
pool-1-thread-1正在执行...
pool-1-thread-2正在执行...
pool-1-thread-1正在执行...

单任务线程池

在上面的代码中只需修改创建pool对象的那行代码即可。

1
2
//创建一个使用单个 worker 线程的 Executor，以无界队列方式来运行该线程。 
ExecutorService pool = Executors.newSingleThreadExecutor();

输出结果:

1
2
3
4
5
pool-1-thread-1正在执行...
pool-1-thread-1正在执行...
pool-1-thread-1正在执行...
pool-1-thread-1正在执行...
pool-1-thread-1正在执行...

可变尺寸的线程池

在上面的代码中只需修改创建pool对象的那行代码即可。

1
2
//创建一个可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们。 
ExecutorService pool = Executors.newCachedThreadPool();

输出结果:

1
2
3
4
5
pool-1-thread-1正在执行...
pool-1-thread-3正在执行...
pool-1-thread-2正在执行...
pool-1-thread-4正在执行...
pool-1-thread-5正在执行...

自定义线程池

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
/***
 * 用显式锁和条件变量实现的可计数的线性池
 *
 */
public class CountableThreadPool {
	private int threadNum;
	private AtomicInteger threadAlive = new AtomicInteger();
	private ReentrantLock reentrantLock = new ReentrantLock();
	private Condition condition = reentrantLock.newCondition();
	public CountableThreadPool(int threadNum) {
		this.threadNum = threadNum;
		this.executorService = Executors.newFixedThreadPool(threadNum);
	}
	public CountableThreadPool(int threadNum, ExecutorService executorService) {
		this.threadNum = threadNum;
		this.executorService = executorService;
	}
	public void setExecutorService(ExecutorService executorService) {
		this.executorService = executorService;
	}
	public int getThreadAlive() {
		return threadAlive.get();
	}
	public int getThreadNum() {
		return threadNum;
	}
	private ExecutorService executorService;
	public void execute(final Runnable runnable) {
		if (threadAlive.get() >= threadNum) {
			try {
				reentrantLock.lock();
				while (threadAlive.get() >= threadNum) {
					try {
						condition.await();
					} catch (InterruptedException e) {
					}
				}
			} finally {
				reentrantLock.unlock();
			}
		}
		threadAlive.incrementAndGet();
		executorService.execute(new Runnable() {
			@Override
			public void run() {
				try {
					runnable.run();
				} finally {
					try {
						reentrantLock.lock();
						threadAlive.decrementAndGet();
						condition.signal();
					} finally {
						reentrantLock.unlock();
					}
				}
			}
		});
	}
	public boolean isShutdown() {
		return executorService.isShutdown();
	}
	public void shutdown() {
		executorService.shutdown();
	}
}
Java
Java, Thread