线程是操作系统调度的最小单元，多个线程同时执行可以显著提升程序性能
JAVA从诞生开始就选择了内置对多线程的支持
一、线程简介
二、启动和终止线程
三、线程间通信
四、线程应用实例
4.1 线程简介
4.1.1 线程
现代操作系统调度的最小单元是线程（Thread），也叫做轻量级进程（Light Weight Process）。
Java程序天生就是一个多线程程序，因为执行main()方法的是一个名称为main的进程，main是用户程序入口。
import java.lang.management.ManagementFactory;
import java.lang.management.ThreadInfo;
import java.lang.management.ThreadMXBean;
public class MultiThread {
public static void main(String[] args) {
// 获取Java线程管理MXBean
ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
// 不需要获取同步的monitor和synchronizer信息，仅仅获取线程和线程堆栈信息
ThreadInfo[] threadInfos = threadMXBean.dumpAllThreads(false, false);
// 遍历线程信息，仅打印线程ID和线程名称信息
for (ThreadInfo threadInfo : threadInfos) {
System.out.println("[" + threadInfo.getThreadId() + "] " + threadInfo.getThreadName());
}
}
}
程序输出：
[5] Attach Listener
[4] Signal Dispatcher
[3] Finalizer
[2] Reference Handler
[1] main
其中，main线程就是我们上文提及的用户程序入口，而且main线程是和其他多个线程同时运行的。
4.1.2 线程的优势
（1）更多的处理器核心
（2）更快的响应时间
（3）更好的变成模型
4.1.3 线程的优先级
在Java线程中，通过一个整型成员变量priority来控制优先级，如：thread.setPriority(5)。优先级1-10，1最高，10最低，默认为5。
4.1.4 线程的状态
Java线程在运行的生命周期中共6个不同的状态。
java中，线程的状态使用一个枚举类型来描述的。这个枚举一共有6个值: NEW(新建)、RUNNABLE(运行)、BLOCKED(锁池)、TIMED_WAITING(定时等待)、WAITING(等待)、TERMINATED(终止)。
4.1.5 Daemon线程
Daemon线程又称为守护线程，它在后台提供一种通用服务的线程。若所有的非守护线程都终止，守护线程也将终止。
4.2 启动和终止线程
4.2.1 构造线程
构造线程时需要提供线程所属的线程组、线程优先级和是否守护线程等信息。当前线程就是该线程的父线程，一个新构造的线程是由其父线程来进行空间分配的。
4.2.2 启动线程
线程start()方法的含义是：当前线程（父线程）同步告知Java虚拟机，只要线程规划器空闲，应立即启动调用start()方法的线程。
4.2.3 理解中断
中断是线程的一个标识位属性，它表示一个运行中的线程是否被其他线程进行了中断操作。
4.2.4 过期操作
不要再使用暂停suspend()、恢复resume()和停止stop()这三个操作。
4.2.5 安全的终止线程
除了中断以外，我们还可以利用一个boolean变量来控制是否需要停止任务并终止该线程，如下面代码中的变量on。
import java.util.concurrent.TimeUnit;
public class Shutdown {
public static void main(String[] args) throws Exception {
Runner one = new Runner();
Thread countThread = new Thread(one, "CountThread");
countThread.start();
// 睡眠1秒，main线程对CountThread进行中断，使CountThread能够感知中断而结束
TimeUnit.SECONDS.sleep(1);
countThread.interrupt();
Runner two = new Runner();
countThread = new Thread(two, "CountThread");
countThread.start();
// 睡眠1秒，main线程对Runner two进行取消，使CountThread能够感知on为false而结束
TimeUnit.SECONDS.sleep(1);
two.cancel();
}
private static class Runner implements Runnable {
private long i = 0;
private volatile boolean on = true;
@Override
public void run() {
while (on && !Thread.currentThread().isInterrupted()) {
i++;
}
System.out.println("Count i = " + i);
}
public void cancel() {
on = false;
}
}
}
4.3 线程间通信
4.3.1 volatile和synchronized关键字
JAVA支持多个线程同时访问一个对象或者对象的成员变量。所以，程序在执行过程中，一个线程看到的变量不一定是最新的。
关键字volatile：告知程序任何对该变量的访问均需要从共享内存中获取，而对它的改变必须同步刷新回共享内存，保证所有线程对变量访问的可见性。
关键字synchronized：可以修饰方法或者以同步块的形式来使用，用来保证同一时刻只能有一个线程处于方法或者同步块中，保证了线程对变量访问的可见性和排他性。
4.3.2 等待/通知机制
一个线程修改了一个对象的值，而另外一个线程感知到了变化，然后进行相应的操作，整个过程开始于一个线程，而最红执行又是另外一个线程。前者是生产者，后者是消费者。
JAVA通过内置的等待/通知机制，能够很好实现生产者和消费者的解耦。
JAVA中所有对象的超类java.lang.Object内置了等待/通知机制，主要包含notify()和wait()两个方法。
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.TimeUnit;
public class WaitNotify {
static boolean flag = true;
static Object lock = new Object();
public static void main(String[] args) throws Exception {
Thread waitThread = new Thread(new Wait(), "WaitThread");
waitThread.start();
TimeUnit.SECONDS.sleep(1);
Thread notifyThread = new Thread(new Notify(), "NotifyThread");
notifyThread.start();
}
static class Wait implements Runnable {
public void run() {
// 加锁，拥有lock的Monitor
synchronized (lock) {
// 当条件不满足时，继续wait，同时释放了lock的锁
while (flag) {
try {
System.out.println(Thread.currentThread() + " flag is true. wait @ "
+ new SimpleDateFormat("HH:mm:ss").format(new Date()));
lock.wait();
} catch (InterruptedException e) {
}
}
// 条件满足时，完成工作
System.out.println(Thread.currentThread() + " flag is false. running @ "
+ new SimpleDateFormat("HH:mm:ss").format(new Date()));
}
}
}
static class Notify implements Runnable {
public void run() {
// 加锁，拥有lock的Monitor
synchronized (lock) {
// 获取lock的锁，然后进行通知，通知时不会释放lock的锁，
// 直到当前线程释放了lock后，WaitThread才能从wait方法中返回
System.out.println(Thread.currentThread() + " hold lock. notify @ " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
System.out.println("通知所有在对象上等待的线程--开始");
lock.notifyAll();
System.out.println("通知所有在对象上等待的线程--完毕");
flag = false;
try {
TimeUnit.SECONDS.sleep(5);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 再次加锁
synchronized (lock) {
System.out.println(Thread.currentThread() + " hold lock again. sleep @ "
+ new SimpleDateFormat("HH:mm:ss").format(new Date()));
try {
TimeUnit.SECONDS.sleep(5);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
源码输出结果：
Thread[WaitThread,5,main] flag is true. wait @ 15:36:53
Thread[NotifyThread,5,main] hold lock. notify @ 15:36:54
通知所有在对象上等待的线程--开始
通知所有在对象上等待的线程--完毕
Thread[NotifyThread,5,main] hold lock again. sleep @ 15:36:59
Thread[WaitThread,5,main] flag is false. running @ 15:37:04
4.3.3 等待/通知的经典范式
该范式分为两个部分：等待方（消费者）和通知方（生产者）。
等待方伪代码：
synchronized(对象){
while(条件不满足){
对象.wait();
}
对应处理逻辑;
}
通知方伪代码：
synchronized(对象){
改变条件;
对象.notifyAll();
}
4.3.4 管道输入/输出流
管道输入/输出流主要用于线程之间的数据传输，而传输的媒介为内存。
4.3.5 Thread.join()的使用
线程A内执行B.join()语句的含义是，当前线程A等待线程B终止之后才从B.join()返回。事实上也是一个等待/通知范式。源码如下：
import java.util.concurrent.TimeUnit;
public class Join {
public static void main(String[] args) throws Exception {
System.out.println("运行main线程.");
Thread previous = Thread.currentThread();
for (int i = 0; i < 2; i++) {
// 每个线程拥有前一个线程的引用，需要等待前一个线程终止，才能从等待中返回
Thread thread = new Thread(new Domino(previous), String.valueOf(i));
thread.start();
TimeUnit.SECONDS.sleep(5);
previous = thread;
}
TimeUnit.SECONDS.sleep(5);
System.out.println(Thread.currentThread().getName() + " terminate.");
}
static class Domino implements Runnable {
private Thread thread;
public Domino(Thread thread) {
this.thread = thread;
}
public void run() {
try {
System.out.println("运行"+Thread.currentThread().getName()+"线程,它的前驱线程名："+thread.getName() + " terminate.");
thread.join();
} catch (InterruptedException e) {
}
System.out.println(Thread.currentThread().getName() + " terminate.");
}
}
}
源码输出：
运行main线程.
运行0线程,它的前驱线程名：main terminate.
运行1线程,它的前驱线程名：0 terminate.
main terminate.
0 terminate.
1 terminate.
每一个线程终止的前提是前驱线程的终止，每一个线程等待前驱线程终止后，才从join方法返回。这里涉及了等待前驱线程结束，接收前驱线程结束通知。
4.3.6 ThreadLocal的使用
ThreadLocal即线程变量，是一个以ThreadLocal对象为键，任意对象为值得存储结构。这个结构被附带在线程上，也就是说一个线程可以根据一个ThreadLocal对象查询到绑定在这个线程上的一个值。
4.4 线程应用实例
4.4.1 等待超时模式
等待超时模式就是在等待/通知范式基础上增加了超时控制，使得该模式不会阻塞。
4.4.2 一个简单的数据库连接池示例
等待超时模式可以用来构造一个简单的数据库连接池。连接池具有获取、使用和释放连接的过程，而客户端获取连接的过程被设定为等待超时的模式，若一定时间内无法获取到可用连接，将会返回给客户端一个null。
4.4.3 线程池技术及其示例
线程池技术：预先创建了若干数量的线程，并且不能由用户直接对线程进行控制，在此基础上复用这些线程完成任务的执行。
好处：
1、消除了频繁创建和消亡线程的系统资源开销。
2、面对过量任务的提交能够平缓的劣化。
本质：
使用了一个线程安全的工作队列连接工作者线程和客户端线程。
4.4.4 一个基于线程池技术的简单web服务器
Web服务器使用主线程不断接受客户端的连接，将连接以及请求提交给线程池处理，这样使得Web服务器能够同时处理多个客户的请求。
线程池中的线程数量并不是越多越好，根据
1、每个任务的处理时间，
2、当前计算机的处理器能力和数量
来决定。
