1.线程池
系统启动一个新线程的成本是比较高的，因为它涉及与操作系统交互。在这种情形下，使用线程池可以很好地提高短暂的线程时，更应该考虑使用线程池。
与数据库连接池类似的是，线程池在系统启动时即创建大量空闲的线程，程序将一个Runnable对象或Callable对象传给线程池，线程池就会启动一个线程来执行他们的run()或call()方法，当run()或call()方法执行结束后，该线程并不会死亡，而是再次返回线程池中称为空闲状态，等待执行下一个Runnable对象的run()或call()方法。
除此之外，使用线程池可以有效地控制系统中并发线程的数量，当系统中包含大量并发线程时，会导致系统性能剧烈下降，甚至导致JVM崩溃，而线程池的最大线程数参数可以控制系统中并发线程数不超过此数。
1.1 java5 实现的线程池
Java 5开始，Java内建支持线程池。Java 5新增了一个Executors工厂类来产生线程池，该工厂类包含如下几个静态工厂方法来创建线程池。
- newCachedThreadPool()：创建一个具有缓存功能的线程池，系统根据需要创建线程，这些线程将会被缓存在线程池中。
- newFixedThreadPool(int nThreads)：创建一个可重用的、具有固定线程数的线程池。
- newSingleThreadExecutor()：创建一个只有单线程的线程池，它相当于调用newFixedThread Pool()方法时传入参数为1。
- newScheduledThreadPool(int corePoolSize)：创建具有指定线程数的线程池，它可以在指定延迟后执行线程任务。corePoolSize指池中所保存的线程数，即使线程是空闲的也被保存在线程池内。
- newSingleThreadScheduledExecutor()：创建只有一个线程的线程池，它可以在指定延迟后执行线程任务。
上面5个方法中的前3个方法返回一个ExecutorService对象，该对象代表一个线程池，它可以执行Runnable对象或Callable对象所代表的线程；而后2个方法返回一个ScheduledExecutorService线程池，它是ExecutorService的子类，它可以在指定延迟后执行线程任务。
ExecutorService代表尽快执行线程的线程池（只要线程池中有空闲线程，就立即执行线程任务），程序只要将一个Runnable对象或Callable对象（代表线程任务）提交给该线程池，该线程池就会尽快执行该任务。ExecutorService里提供了如下3个方法：
- Future<?> submit(Runnable task)：将一个Runnable对象提交给指定的线程池，线程池将在有空闲线程时执行Runnable对象代表的任务。其中Future对象代表Runnable任务的返回值——但run()方法没有返回值，所以Future对象将在run()方法执行结束后返回null。但可以调用Future的isDone()、isCancelled()方法来获得Runnable对象的执行状态。
- Future submit(Runnable task, T result)：将一个Runnable对象提交给指定的线程池，线程池将在有空闲线程时执行Runnable对象代表的任务。其中result显式指定线程执行结束后的返回值，所以Future对象将在run()方法执行结束后返回result。
- Future submit(Callable task)：将一个Callable对象提交给指定的线程池，线程池将在有空闲线程时执行Callable对象代表的任务。其中Future代表Callable对象里call()方法的返回值。
ScheduledExecutorService代表可在指定延迟后或周期性地执行线程任务的线程池，它提供了如下4个方法：
- ScheduledFuture schedule(Callable callable, long delay, TimeUnit unit)：指定callable任务将在delay延迟后执行。
- ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit)：指定command任务将在delay延迟后执行。
- ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)：指定command任务将在delay延迟后执行，而且以设定频率重复执行。也就是说，在initialDelay后开始执行，依次在initialDelay+period、initialDelay+2 * period…处重复执行，依此类推。
- ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay,TimeUnit unit)：创建并执行一个在给定初始延迟后首次启用的定期操作，随后在每一次执行终止和下一次执行开始之间都存在给定的延迟。如果任务在任一次执行时遇到异常，就会取消后续执行；否则，只能通过程序来显式取消或终止该任务。
当完成一个线程池后，应该调用该线程池的shutdown()方法，该方法将启动线程池的关闭序列，调用shutdown()方法后的线程池不再接收新任务，但会将以前所有已提交任务执行完成。当线程池中的所有任务都执行完成后，池中的所有线程都会死亡；另外也可以调用线程池的shutdownNow()方法来关闭线程池，该方法试图停止所有正在执行的活动任务，暂停处理正在等待的任务，并返回等待执行的任务列表。
使用线程池来执行线程任务的步骤如下：
- 调用Executors类的静态工厂方法创建一个ExecutorService对象，该对象代表一个线程池。
- 创建Runnable实现类或Callable实现类的实例，多为线程执行任务。
- 调用ExecutorService对象的submit()方法来提交Runnable实例或Callable实例。
- 当不想提交任何任务时，调用ExecutorService对象的shutdown()方法来关闭线程池。
下面程序使用线程池来执行指定Runnable对象所代表的任务：
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
// 实现Runnable接口来定义一个简单的线程类
class MyThread implements Runnable {
public void run() {
for (int i=0; i < 100 ; i++ ) {
System.out.println(Thread.currentThread().getName()
+ "的i值为:" + i);
}
}
}
public class ThreadPoolTest {
public static void main(String[] args)
throws Exception {
// 创建一个具有固定线程数（6）的线程池
ExecutorService pool= Executors.newFixedThreadPool(6);
// 向线程池中提交两个线程
pool.submit(new MyThread());
pool.submit(new MyThread());
// 关闭线程池
pool.shutdown();
}
}
上面程序中创建Runnable实现类与最开始创建线程池并没有太大差别，创建了Runnable实现类之后程序没有直接创建线程、启动线程来执行该Runnable任务，而是通过线程池来执行该任务，使用线程池来执行Runnable任务的代码如程序中粗体字代码所示。运行上面程序，将会看到两个线程交替执行的效果：
pool-1-thread-1的i值为:0
pool-1-thread-2的i值为:0
pool-1-thread-1的i值为:1
pool-1-thread-2的i值为:1
pool-1-thread-1的i值为:2
pool-1-thread-1的i值为:3
pool-1-thread-2的i值为:2
pool-1-thread-1的i值为:4
pool-1-thread-2的i值为:3
1.2 Java 7新增的ForkJoinPool
现在计算机大多已向多CPU方向发展，即使普通PC，甚至小型智能设备（如手机）、多核处理器也已被广泛应用。在未来的日子里，处理器的核心数将会发展到更多。
虽然硬件上的多核CPU已经十分成熟，但很多应用程序并未为这种多核CPU做好准备，因此并不能很好地利用多核CPU的性能优势。
为了充分利用多CPU、多核CPU的性能优势，计算机软件系统应该可以充分“挖掘”每个CPU的计算能力，绝不能让某个CPU处于“空闲”状态。为了充分利用多CPU、多核CPU的优势，可以考虑把一个任务拆分成多个“小任务”，把多个“小任务”放到多个处理器核心上并行执行；当多个“小任务”执行完成之后，再将这些执行结果合并起来即可。
Java7提供了ForkJoinPool来支持将一个任务拆分成多个“小任务”并行计算，再把多个“小任务”的结果合并成总的计算结果。ForkJoinPool是ExecutorService的实现类，因此是一种特殊的线程池。ForkJoinPool提供了如下两个常用的构造器。
- ForkJoinPool(int parallelism)：创建一个包含parallelism个并行线程的ForkJoinPool。
- ForkJoinPool()：以Runtime.availableProcessors()方法的返回值作为parallelism参数来创建Fork JoinPool。
创建了ForkJoinPool实例之后，就可调用ForkJoinPool的submit(ForkJoinTask task)或invoke (ForkJoinTask task)方法来执行指定任务了。其中ForkJoinTask代表一个可以并行、合并的任务。ForkJoinTask是一个抽象类，它还有两个抽象子类：RecursiveAction和RecursiveTask。其中RecursiveTask代表有返回值的任务，而RecursiveAction代表没有返回值的任务。
下面以执行没有返回值的“大任务”（简单地打印0~300的数值）为例，程序将一个“大任务”拆分成多个“小任务”，并将任务交给ForkJoinPool来执行：
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveAction;
import java.util.concurrent.TimeUnit;
// 继承RecursiveAction来实现“可分解”的任务
class PrintTask extends RecursiveAction {
// 每个“小任务”最多只打印50个数
private static final int THRESHOLD=50;
private int start;
private int end;
// 打印从start到end的任务
public PrintTask(int start, int end) {
this.start=start;
this.end=end;
}
@Override
protected void compute() {
// 当end与start之间的差小于THRESHOLD时，开始打印
if(end - start < THRESHOLD) {
for (int i=start ; i < end ; i++ ) {
System.out.println(Thread.currentThread().getName()
+ "的i值：" + i);
}
}
else {
// 当end与start之间的差大于THRESHOLD，即要打印的数超过50个时
// 将大任务分解成两个“小任务”
int middle=(start + end) /2;
PrintTask left=new PrintTask(start, middle);
PrintTask right=new PrintTask(middle, end);
// 并行执行两个“小任务”
left.fork();
right.fork();
}
}
}
public class ForkJoinPoolTest {
public static void main(String[] args) throws Exception {
ForkJoinPool pool=new ForkJoinPool();
// 提交可分解的PrintTask任务
pool.submit(new PrintTask(0 , 300));
pool.awaitTermination(2, TimeUnit.SECONDS);
// 关闭线程池
pool.shutdown();
}
}
上面程序实现了对指定打印任务的分解，分解后的任务分别调用fork()方法开始并行执行。ForkJoinPool启动了两个线程来执行这个打印任务——这是因为笔者的计算机的CPU是双核的。不仅如此，读者可以看到程序虽然打印了0～299这300个数字，但并不是连续打印的，这是因为程序将这个打印任务进行了分解，分解后的任务会并行执行，所以不会按顺序从0打印到299。
上面定义的任务是一个没有返回值的打印任务，如果大任务是有返回值的任务，则可以让任务继承RecursiveTask，其中泛型参数T就代表了该任务的返回值类型。下面程序示范了使用Recursive Task对一个长度为100的数组的元素值进行累加：
import java.util.Random;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.Future;
import java.util.concurrent.RecursiveTask;
// 继承RecursiveTask来实现“可分解”的任务
class CalTask extends RecursiveTask<Integer> {
// 每个“小任务”最多只累加20个数
private static final int THRESHOLD=20;
private int arr[];
private int start;
private int end;
// 累加从start到end的数组元素
public CalTask(int[] arr , int start, int end) {
this.arr=arr;
this.start=start;
this.end=end;
}
@Override
protected Integer compute() {
int sum=0;
// 当end与start之间的差小于THRESHOLD时，开始进行实际累加
if(end - start < THRESHOLD) {
for (int i=start ; i < end ; i++ ) {
sum +=arr[i];
}
return sum;
}
else {
// 当end与start之间的差大于THRESHOLD，即要打印的数超过20个时
// 将大任务分解成两个“小任务”
int middle=(start + end) /2;
CalTask left=new CalTask(arr , start, middle);
CalTask right=new CalTask(arr , middle, end);
// 并行执行两个“小任务”
left.fork();right.fork();
// 把两个“小任务”累加的结果合并起来
return left.join() + right.join(); //①
}
}
}
public class Sum {
public static void main(String[] args) throws Exception {
int[] arr=new int[100];
Random rand=new Random();
int total=0;
// 初始化100个数字元素
for (int i=0 , len=arr.length; i < len ; i++ ) {
int tmp=rand.nextInt(20);
// 对数组元素赋值，并将数组元素的值添加到total总和中
total +=(arr[i]=tmp);
}
System.out.println(total);
ForkJoinPool pool=new ForkJoinPool();
// 提交可分解的CaltTask任务
Future<Integer> future=pool.submit(new CalTask(arr , 0 , arr.length));
System.out.println(future.get());
// 关闭线程池
pool.shutdown();
}
}
上面程序与前一个程序基本相似，同样是将任务进行了分解，并调用分解后的任务的fork()方法使它们并行执行。与前一个程序不同的是，现在任务是带返回值的，因此程序还在①号代码处将两个分解后的“小任务”的返回值进行了合并。
运行上面程序，将可以看到程序通过CalTask计算出来的总和，与初始化数组元素时统计出来的总和总是相等，这表明程序一切正常。
2.ThreadLocal类
通过使用ThreadLocal类可以简化多线程编程时的并发访问，使用这个工具类可以很简洁地隔离多线程程序的竞争资源。
ThreadLocal，是ThreadLocalVariable(线程局部变量)的意思，也许将它命名为ThreadLocalVar更加合适。线程局部变量（ThreadLocal）的功用其实非常简单，就是为每一个使用该变量的线程都提供一个变量值的副本，是每一个线程都可以独立地改变自己的副本，而不会和其他线程的副本冲突。从线程的角度看，就好像每一个线程都完成拥有该变量一样。
ThreadLocal类的用法非常简单，它只提供了如下3个public方法。
- T get()：返回此线程局部变量中当前线程副本中的值。
- void remove（）：删除此线程局部变量中当前线程的值。
- void set（T value）：设置此线程局部变量中当前线程副本中的值。
下面程序将向读者证明ThreadLocal的作用。
class Account {
/* 定义一个ThreadLocal类型的变量，该变量将是一个线程局部变量
每个线程都会保留该变量的一个副本 */
private ThreadLocal<String> name=new ThreadLocal<>();
// 定义一个初始化name属性的构造器
public Account(String str) {
this.name.set(str);
//下面代码用于访问当前线程的name副本的值
System.out.println("---" + this.name.get());
}
// name的setter和getter方法
public String getName() {
return name.get();
}
public void setName(String str) {
this.name.set(str);
}
}
class MyTest extends Thread {
// 定义一个Account属性
private Account account;
public MyTest(Account account, String name) {
super(name);
this.account=account;
}
public void run() {
// 循环10次
for (int i=0 ; i < 10 ; i++) {
// 当i==6时输出将账户名替换成当前线程名
if (i==6) {
account.setName(getName());
}
// 输出同一个账户的账户名和循环变量
System.out.println(account.getName()+ " 账户的i值：" + i);
}
}
}
public class ThreadLocalTest {
public static void main(String[] args) {
// 启动两个线程，两个线程共享同一个Account
Account at=new Account("初始名");
/*
虽然两个线程共享同一个账户，即只有一个账户名
但由于账户名是ThreadLocal类型的，所以每个线程
都完全拥有各自的账户名副本，因此在i==6之后，将看到两个
线程访问同一个账户时出现不同的账户名
*/
new MyTest(at , "线程甲").start();
new MyTest(at , "线程乙").start ();
}
}
上面Account类中分别完成了创建ThreadLocal对象、从ThreadLocal中取出线程局部变量、修改线程局部变量的操作。由于程序中的账户名是一个ThreadLocal变量，所以虽然程序中只有一个Account对象，但两个子线程将会产生两个账户名（主线程也持有一个账户名的副本）。两个线程进行循环时都会在i==6时将账户改名为与线程名相同，这样我们就可以看到两个线程拥有两个账户名的情形。
从上面程序可以看出，实际上账户名有3个副本，主线程一个，另外启动的两个线程各一个，它们的值互不干扰，每个线程完全拥有自己的ThreadLocal变量，这就是ThreadLocal的用途。
ThreadLocal和其他所有的同步机制一样，都是为了解决多线程中对同一变量的访问冲突，在普通的同步机制中，是通过对象加锁来实现多个线程对同一变量的安全访问的。该变量是多个线程共享的，所以要使用这种同步机制，需要很细致地分析在什么时候对变量进行读写，什么时候需要锁定某个对象，什么时候释放该对象的锁等。在这种情况下，系统并没有将这份资源复制多份，只是采用了安全机制来控制对这份资源的访问而已。
ThreadLocal从另一个角度来解决多线程的并发访问，ThreadLocal将需要并发访问的资源复制多份，每个线程拥有一份资源，每个线程都拥有自己的资源副本，从而也就没有必要对该变量进行同步了。ThreadLocal提供了线程安全的共享对象，在编写多线程代码时，可以把不安全的整个变量封装进ThreadLocal，或者把该对象与线程相关的状态使用ThreadLocal保存。
ThreadLocal并不能替代同步机制，两者面向的问题领域不同。同步机制是为了同步多个线程对相同资源的并发访问，是多个线程之间进行通信的有效方式；而ThreadLocal是为了隔离多个线程的数据共享，从根本上避免多个线程之间对共享资源（变量）的竞争，也就不需要对多个线程进行同步了。
通常我们认为：如果多个线程之间需要共享资源，以达到线程之间的通信功能，就使用同步机制；如果仅仅需要隔离多个线程之间的共享冲突，则可以使用ThreadLocal。
3. Java编程练习
3.1医院手术任务（线程池任务）
多线程技术主要解决处理器单元内多个线程执行的问题，它可以显著减少处理器单元的闲置时间，增加处理器单元的吞吐能力。本例将以一个医院手术任务为例为大家讲解Java线程池的用法
3.1.1.
新建项目SurgeryThreadPool，并在其中创建一个SurgeryThreadPool.java文件。在该类的主方法中创建一个有三个任务线程的线程池，并在休眠600毫秒后，让线程池中的任务线程全部运行。核心代码如下所示：
package SurgeryThreadPool;
import java.util.*;
public class SurgeryThreadPool {
private static Runnable createTask(final int taskID) { // 创建任务方法
return new Runnable() {
public void run() { // 创建手术任务
System.out.println("手术开始,编号为" + taskID);
System.out.println("正在手术中～～");
System.out.println("手术结束,编号为" + taskID);
}
};
}
public static void main(String[] args) { // Java程序主入口处
ThreadTask threadPool = new ThreadTask(3); // 创建一个有三个任务线程的线程池
try { // 休眠600毫秒，让线程池中的任务线程全部运行
Thread.sleep(600);
} catch (InterruptedException e) { // 捕获拦截异常
System.out.println("线程休眠出错：" + e.getMessage());
}
for (int i = 0; i < 3; i++) { // 循环创建并执行任务
threadPool.addTask(createTask(i));
}
threadPool.waitTaskColsed(); // 等待所有任务执行完毕
threadPool.closePool(); // 关闭线程池
}
}
3.1.2
创建一个ThreadTask类继承线程池功能，实现三个线程任务的有序执行，核心代码如下所示：
package SurgeryThreadPool;
import java.util.LinkedList;
class ThreadTask extends ThreadGroup { // 继承线程组实现线程池功能
private boolean isStop = false; // 线程池是否关闭
private LinkedList queue; // 工作任务队列
private static int poolID = 1; // 线程池的编号
private class SurgeryTask extends Thread {// 负责从工作队列中取出任务并执行的内部类
private int id; // 任务编号
public SurgeryTask(int id) { // 构造方法进行初始化
super(ThreadTask.this, id + ""); // 将线程加入到当前线程组中
this.id = id;
}
public void run() {
while (!isInterrupted()) { // 判断线程是否被中断
Runnable task = null;
task = getTask(id); // 取出任务
// 如果getTask()返回null或者线程执行getTask()时被中断，则结束此线程
if (task == null)
return;
try {
task.run(); // 运行任务
} catch (Throwable t) {
t.printStackTrace();
}
}
}
}
public ThreadTask(int size) { // 构造方法传入线程池中的工作线程的数量
super(poolID + ""); // 指定线程组名称
setDaemon(true); // 继承线程组的方法用来设置是否守护线程池
queue = new LinkedList(); // 创建工作任务队列
for (int i = 0; i < size; i++) { // 循环创建任务线程
new SurgeryTask(i).start(); // 根据线程池数据创建任务线程并启动线程
}
}
public synchronized void addTask(Runnable task) { // 添加新任务并执行任务
if (isStop) { // 判断标识
throw new IllegalStateException(); // 抛出不合理状态异常
}
if (task != null) {
queue.add(task); // 向任务队列中加入一个任务
notify(); // 唤醒待任务的工作任务线程
}
}
private synchronized Runnable getTask(int id) {// 取出任务
try {
while (queue.size() == 0) { // 循环使线程等待任务
if (isStop)
return null;
System.out.println("病人" + id + "正在等待手术...");
wait(); // 如果任务队列中没有任务，就等待任务
}
} catch (InterruptedException e) { // 捕获拦截异常
System.out.println("等待治疗出现错误：" + e.getMessage());
}
System.out.println("病人" + id + "开始执行手术...");
return (Runnable) queue.removeFirst(); // 返回第一个任务并从队列中删除
}
public synchronized void closePool() { // 关闭线程池
if (!isStop) { // 判断标识
waitTaskColsed(); // 等待任务线程执行完毕
isStop = true; // 标识为真
queue.clear(); // 任务队列清空
interrupt(); // 唤醒线程池中的所有的工作线程
}
}
public void waitTaskColsed() { // 等待任务线程把所有任务执行完毕
synchronized (this) {
isStop = true; // 标识为真
notifyAll(); // 唤醒待任务的工作任务线程
}
Thread[] threads = new Thread[activeCount()]; // 创建线程组中活动的线程组
int count = enumerate(threads); // 获得线程组中当前所有活动的工作线程
for (int i = 0; i < count; i++) { // 循环等待所有工作线程结束
try {
threads[i].join(); // 等待工作线程结束
} catch (InterruptedException e) { // 捕获拦截异常
System.out.println("手术失败：" + e.getMessage());
}
}
}
}
多线程技术主要解决处理器单元内多个线程执行的问题，它可以显著减少处理器单元的闲置时间，增加处理器单元的吞吐能力。
假设一个服务器完成一项任务所需时间为：T1是创建线程时间，T2是在线程中执行任务的时间，T3是销毁线程时间。如果T1+T3远大于T2，则可以采用线程池，以提高服务器性能。
一个线程池包括以下四个基本组成部分：
- 线程池管理器（ThreadPool）：用于创建并管理线程池，包括创建线程池，销毁线程池，添加新任务。
- 工作线程（PoolWorker）：线程池中线程，在没有任务时处于等待状态，可以循环的执行任务。
- 任务接口（Task）：每个任务必须实现的接口，以供工作线程调度任务的执行，它主要规定了任务的入口，任务执行完后的收尾工作，任务的执行状态等。
- 任务队列（TaskQueue）：用于存放没有处理的任务。提供一种缓冲机制。
线程池技术正是关注如何缩短或调整T1、T3时间的技术，从而提高服务器程序性能的。它把T1、T3分别安排在服务器程序的启动和结束的时间段或者一些空闲的时间段，这样在服务器程序处理客户请求时，不会有T1、T3的开销了。线程池不仅调整T1、T3产生的时间段，而且它还显著减少了创建线程的数目，下面是一个例子：
假设一个服务器一天要处理50000个请求，并且每个请求需要一个单独的线程完成。在线程池中，线程数一般是固定的，所以产生线程总数不会超过线程池中线程的数目，而如果服务器不利用线程池来处理这些请求，则线程总数为50000。一般线程池大小远小于50000。所以利用线程池的服务器程序不会为了创建50000个线程而在处理请求时浪费时间，从而提高效率。