前言:Java从诞生开始就明智地选择了内置对多线程的支持，这使得Java语言相比同一时期的其他语言具有的有事.线程作为操作系统调度的最小单元,多个线程能够同时执行,这将显著提升程序性能,在多核环境中显得更加明显.但是,过多的创建线程和对线程的不当管理也容易造成问题.
线程简介
什么是线程
线代操作系统在运行一个程序的时候,会为其创建一个进程.例如,启动一个Java程序,操作系统就会创建一个Java进程.现代操作系统调度的最小单元是线程,也叫轻量级进程(Light Weight Process),在一个进程里可以创建多个线程,这些线程拥有各自的计数器,堆栈和局部变量等属性,并且能够访问内存的贡献变量.处理器在这些线程上高速切换,让使用者感觉到这些线程在同时执行.
一个Java程序从main()方法开始执行，然后按照既定的代码逻辑执行，看似没有其他线程参与，但实际上Java程序天生就是多线程程序，因为执行main()方法的是一个名称为main的线程。
一个Java程序运行的不仅仅是main()方法的运行,而是main线程和多个其他线程的同时运行.
为什么要使用多线程
1.更多的处理器核心
随着处理器上的核心数量越来越多以及超线程技术的广泛运用，现在大多数计算机都比以往更加擅长并行计算,而处理器性能的提升方式,也从更高的主频想更多的核心发展.
线程是大多数操作系统调度的基本单元,一个程序作为一个进程来运行,程序运行过程中能够创建多个线程,而一个线程在一个时刻只能运行在一个处理器核心上,如果将该程序使用多线程技术,将计算逻辑分配到多个处理器核心上,就会显著减少程序的执行时间,并且虽则更多处理器核心的加入变得更加有效率.
2.更快的响应时间
有时我们会编写一些较为复杂的代码,例如，一笔订单的创建，它包括插入订单数据、生成订单快照、发送邮件通知卖家和记录货品销售数量等。用户从单击“订购”按钮开始，就要等待这些操作全部完成才能看到订购成
功的结果。但是这么多业务操作，如何能够让其更快地完成呢？
在上面的场景中,可以使用多线程技术,即将数据一致性不强的操作派发给其他线程处理(也可以使用消息队列),如生成订单快照、发送邮件等。这样做的好处是响应用户请求的线程能够尽可能快地处理完成，缩短了响应时间，提升了用户体验。
3.更好的编程模型
Java为多线程编程提供了良好、考究并且一致的编程模型，使开发人员能够更加专注于问题的解决，即为所遇到的问题建立合适的模型，而不是绞尽脑汁地考虑如何将其多线程化。一旦开发人员建立好了模型，稍做修改总是能够方便地映射到Java提供的多线程编程模型上。
线程优先级
线代操作系统基本采用时分的形式调度运行的线程,操作系统会分出一个个时间片,线程会分配到若干时间片,当线程的时间片用完了就会发生线程调度,并等待下次分配.线程分配到的时间片多少也决定了线程使用处理器资源的多少,而线程优先级就是决定线程需要多或者少分配一些处理器资源的线程属性.
在Java线程中,通过一个整型变量priority来控制优先级优先级的范围从1~10，在线构建的时候可以通过setPriority(int)方法来修改优先级,默认优先级是5,优先级搞得线程分配时间片的数量要多于优先级低的线程.设置线程优先级时,针对频繁阻塞（休眠或者I/O操作）的线程需要设置较高优先级，而偏重 计算(需要较多CPU时间或偏重计算(需要较多CPU时间或偏运算)的线程则设置较低优先级,确保处理器不会被独占.在不同的JVM以及操作系统上,线程规则会存在差异,有些操作系统甚至会忽略对线程优先级的设定.
从输出可以看到线程优先级没有生效，优先级1和优先级10的Job计数的结果非常相近，没有明显差距。这表示程序正确性不能依赖线程的优先级高.
注意: 线程优先级不能作为程序正确性的依赖,因为操作系统可以完全不用例会Java线程对优先级的设定.
线程的状态
Java线程在运行的生命周期可能处于以下中的6种不同的状态,在给定的一个时刻,线程只能处于其中的一个状态.
打开终端->输入jps
可以看到运行示例对应的进程ID是929，接着再键入“jstack 929”（这里的进程ID需要和读者自己键入jps得出的ID一致），部分输出如下所示。
线程在自身的生命周期中，并不是固定地处于某个状态，而是随着代码的执行在不同的状态之间进行切换，Java线程状态变迁如图Java线程状态变迁所示。
线程创建之后,调用start()方法开始运行。当线程执行wait()方法之后，线程进入等待状态。进入等待状态的线程需要依靠其他线程的通知才能够返回到运行状态，而超时等待状态相当于在等待状态的基础上增加了超时限制，也就是超时时间到达时将会返回到运行状态。当线程调用同步方法时,在没有获取到锁的情况下,线程将会进入到阻塞状态.线程在执行Runnable的run()方法之后将会进入到终止状态。
注意:Java将操作系统中的运行和就绪两个状态合并称为运行状态.阻塞状态是线程阻塞进入synchronized关键字修饰的方法或代码块（获取锁）时的状态，但是阻塞在java.concurrent包中Lock接口的线程状态却是等待状态，因为java.concurrent包中Lock接口对于阻塞的实现均使用了LockSupport类中的相关方法。
Daemon线程
Daemon线程是一种支持型线程，因为它主要被用作程序中后台调度以及支持性工作。这意味着,当一个Java虚拟机中不存在非Daemon线程的时候,Java虚拟机将会退出.可以通过调用用Thread.setDaemon(true)将线程设置为Daemon线程。
注意:Daemon属性需要在启动之间设置,不能在线程之后设置.
Daemon线程被用作完成支持性工作，但是在Java虚拟机退出时Daemon线程中的finally块并不一定会执行.
运行Daemon程序，可以看到在终端或者命令提示符上没有任何输出。main线程（非Daemon线程）在启动了线程DaemonRunner之后随着main方法执行完毕而终止，而此时Java虚拟机中已经没有非Daemon线程，虚拟机需要退出。Java虚拟机中的所有Daemon线程都需要立即终止，因此DaemonRunner立即终止，但DaemonRunner中的finally块并没有执行。
注意:在构件Daemon线程时,不能依靠finally块中的内容来确保执行关闭或清理资源的逻辑.
启动和终止线程
构造线程
在运行线程之前首先要构造一个线程对象,线程对象在构造的时候需要提供线程所需要的属性,如线程所属的线程组,现成的优先级,是否有Daemon线程等信息.
上述过程中,一个新构造的线程对象是由parent线程来进行空间分配,而child线程继承了parent是否为Daemon,优先级和加载资源的contextClassLoader以及科技城的ThreadLocal,通知还会分配一个唯一的ID来标识这个child线程。至此,一个能够运行的线程就初始化好了,在堆内存中等待着运行.
启动线程
线程在对象完成初始化之后,调用start()方法可以启动这个线程.线程start()方法的含义是:当前线程(即parent线程)同步告知Java虚拟机,只要线程规划期空闲.应立即调用start()方法的线程.
注意:启动一个线程前,最好为这个线程设置线程名称,因为这样在使用jstack分析程序或者进行问题排查时更方便.
理解中断
相关博客可见:https://www.jianshu.com/p/78c88e5e7988
中断可以理解为线程的一个标示位属性,它表示一个运行中的线程是否被其他线程进行了中断操作.中断好比其他线程对该线程打了个招呼,其他线程通过调用该线程的interrupt()方法对其进行中断操作.
线程通过检查自身是否被中断来进行响应,线程通过方法isInterrupted来进行判断是否被中断，也可以调用静态方法Thread.interrupted()对当前线程的中断标识位进行复位。如果该线程已经处于终结状态，即使该线程被中断过，在调用该线程对象的isInterrupted()时依旧会返回false。
下述示例代码中,，首先创建了两个线程，SleepThread和BusyThread，前者不停地睡眠，后者一直运行，然后对这两个线程分别进行中断操作，观察二者的中断标识位。
从结果可以看出，抛出InterruptedException的线程SleepThread，其中断标识位被清除了，而一直忙碌运作的线程BusyThread，中断标识位没有被清除.
过期的suspend()、resume()和stop
如果把它播放音乐比作一个线程的运作，那么对音乐播放做出的暂停、恢复和停止操作对应在线程Thread的API就是suspend()、resume()和stop()。
在下述代码清单中,创建一个PrintThread.以1秒的频率进行打印,而主线程对其进行暂停,恢复和 停止操作.
输出如下（输出内容中的时间与示例执行的具体时间相关）。
在执行过程中，PrintThread运行了3秒，随后被暂停，3秒后恢复，最后经过3秒被终止.
通过示例的输出可以看到,suspend(),resume()和stop()方法完成了线程的暂停,恢复和终止工作.而且非常"人性化".但是这些API是不建议使用的.
不建议使用的主要原因主要有:以suspend()方法为例，在调用后，线程不会释放已经占有的资源（比如锁），而是占有着资源进入睡眠状态，这样容易引发死锁问题。同样，stop()方法在一个线程时不会保证线程的资源正常释放，通常是没有给予线程完成资源释放工作的机会，因此会导致程序可能工作在不确定状态下。
注意:正因为suspend()、resume()和stop()方法带来的副作用，这些方法才被标注为不建议使用的过期方法，而暂停和恢复操作可以用后面提到的等待/通知机制来替代。
安全地终止线程
中断标志是一个线程的标识符,而中断操作是一种简便的线程间交互方式,而这种交互方式最适合用来取消或停止任务.除中断意外,还可以利用一个boolean变量来控制是否需要停止任务并终止该线程.
在下述的代码清单中,创建了一个线程CountThread，它不断地进行变量累加，而主线程尝试对其进行中断操作和停止操作。
输出结果如下所示（输出内容可能不同）。
示例在执行过程中,main线程通过中断操作和cancel()方法均可使CountThread得以终止.这种通过标示位或者中断操作的方式使得线程在终止时有机会去清理资源,而不是武断的将线程通知,因此这种终止线程的方式更加安全和优雅.
线程之间的通信
线程开始运行,拥有自己的栈空间,就如同一个监本一样,按照规定的代码一步一步地执行,直到终止.如果多个线程能够相互配合完成工作,浙江带来巨大的截止.(如果是每个线程之间单独运行将带来很少的价值,甚至,没有价值).
volatile和synchronized关键字
Java支持多个线程同事访问一个对象或者对象的成员变量.由于每个线程之间可以拥有这个变量的拷贝(虽然对象以及成员变量分配的内存是在共享内存中的,但是每个执行的线程还是可以拥有一份拷贝,这样做的目的是加速程序的执行,这是现代多核处理器的一个显著特性),所以程序在执行过程中,一个线程看到的变量不一定是最新的.
- 关键字volatile可以用来修饰字段(成员变量),告知程序任何对该变量的访问均需要从共享内存中获取,而对它的改变必须同步刷新回共享内存,它能保证所有线程对变量访问的可见性.
举个例子，定义一个表示程序是否运行的成员变量boolean on=true，那么另一个线程可能对它执行关闭动作（on=false），这里涉及多个线程对变量的访问，因此需要将其定义成为volatile boolean on＝true，这样其他线程对它进行改变时，可以让所有线程感知到变化，因为所有对on变量的访问和修改都需要以共享内存为准。但是，过多地使用volatile是不必要的，因为它会降低程序执行的效率。
注意:volatile不适用于计数器的场景.volatile++是不具有原子性的
关键字synchronized可以修饰方法或者以同步代码块的形式来进行使用,它主要确保多个线程在同意时刻,只能有一个线程处于方法或者是代码块中,它保证了线程对变量访问的可见性和排他性.
在下述的代码清单当中,使用了同步块和同步方法,同股哟Javap工具查看商城的class文件信息来分析synchronized关键字的实现细节.
在synchronized.class统计目录执行javap–v Synchronized.class，部分相关输出如下所示
上面的class信息中,对于同步块的实现使用了
moniterenter和moniterexit指令,而同步方法则是依靠方法修饰符上的ACC_SYNCHRONIZED来完成的。无论是采用哪种方式,其本质是对一个对象监视器(moniter)进行获取,而这个获取过程是排他的,也就是同一个时刻只能有一个线程获取到由synchronized所保护对象的监视器。
任意一个对象都拥有自己的监视器,单跟这个对象由同步代码块或者这个对象的同步方法调用时,执行方法的线程必须先获取到该对象的监视器才能进入同步代码块或者同步方法,而没有获取到监视器(执行该方法)的线程将会被阻塞在同步快和同步方法的入口处,进入BLOCKED状态.
任意线程对Object（Object由synchronized保护）的访问，首先要获得Object的监视器。如果获取失败，线程进入同步队列，线程状态变为BLOCKED。当访问Object的前驱（获得了锁的线程）释放了锁，则该释放操作唤醒阻塞在同步队列中的线程，使其重新尝试对监视器的获取。
等待/通知机制
一个线程修改了一个对象的值,而另一个线程感知到了变化,然后进行相应的操作,整个过程开始于一个线程,而最终执行又是另一个线程.前者是生产者,后者是消费者,这种模式隔离了了“做什么”（what）和“怎么做”（How），在功能层面上实现了解耦，体系结构上具备了良好的伸缩性，但是在Java语言中如何实现类似的功能呢？
简单的方法就是让消费者线程不断循环检查变量是否符合预期.
上面的这段伪代码在条件不满足时就睡眠一段时间,这样做的目的是防止过快的"无效尝试",这种方式看似能够实现所需的功能,但是存在以下的问题.
- 难以确保及时性。在睡眠时，基本不消耗处理器资源，但是如果睡得过久，就不能及时发现条件已经变化，也就是及时性难以保证。
- 难以降低开销。如果降低睡眠的时间，比如休眠1毫秒，这样消费者能更加迅速地发现条件变化，但是却可能消耗更多的处理器资源，造成了无端的浪费。
以上两个问题，看似矛盾难以调和，但是Java通过内置的等待/通知机制能够很好地解决这个矛盾并实现所需的功能。
等待/通知的相关方法是任意Java对象都具备的，因为这些方法被定义在所有对象的超类
java.lang.Object上
关于notify和notifyAll的区别:https://www.jianshu.com/p/26bfde335e78
等待/通知机制:指一个线程A调用了对象O的wait()方法进入等待状态，而另一个线程B调用了对象O的notify()或者notifyAll()方法，线程A收到通知后从对象O的wait()方法返回，进而执行后续操作。上述两个线程通过对象O来完成交互，而对象上的wait()和notify/notifyAll()的关系就如同开关信号一样，用来完成等待方和通知方之间的交互工作。
下述所示的例子中,创建了两个线程——WaitThread和NotifyThread，前者检查flag值是否为false，如果符合要求，进行后续操作，否则在lock上等待，后者在睡眠了一段时间后对lock进行通知.
输出如下（输出内容可能不同，主要区别在时间上）。
上述第3行和第4行输出的顺序可能会互换，而上述例子主要说明了调用wait()、notify()以及notifyAll()时需要注意的细节，如下。
1.使用wait()、notify()和notifyAll()时需要先对调用对象加锁。
2.调用wait()方法后，线程状态由RUNNING变为WAITING，并将当前线程放置到对象的等待队列。
3.notify()或notifyAll()方法调用后，等待线程依旧不会从wait()返回，需要调用notify()或notifAll()的线程释放锁之后，等待线程才有机会从wait()返回。
4.notify()方法将等待队列中的一个等待线程从等待队列中移到同步队列中，而notifyAll()方法则是将等待队列中所有的线程全部移到同步队列，被移动的线程状态由WAITING变为BLOCKED。
5.从wait()方法返回的前提是获得了调用对象的锁。
等待/通知机制依托于同步机制，其目的就是确保等待线程从wait()方法返回时能够感知到通知线程对变量做出的修改.
WaitThread首先获取了对象的锁，然后调用对象的wait()方法，从而放弃了锁并进入了对象的等待队列WaitQueue中，进入等待状态。由于WaitThread释放了对象的锁，NotifyThread随后获取了对象的锁，并调用对象的notify()方法，将WaitThread从WaitQueue移到SynchronizedQueue中，此时WaitThread的状态变为阻塞状态。NotifyThread释放了锁之后，WaitThread再次获取到锁并从wait()方法返回继续执行。
等待/通知的经典范式
从上述的WaitNotify示例中可以提炼出等待/通知的经典范式，该范式分为两部分，分别针对等待方（消费者）和通知方（生产者）。
- 等待方遵循如下规则
1.获取对象的锁
2.如果条件不满足,那么调用对象的wait()方法,被通知后仍要检查条件.
3.条件满足则执行对应的逻辑.
对应的伪代码如下
- 通知方遵循如下规则
1.获得对象的锁。
2.改变条件。
3.通知所有等待在对象上的线程。
对应的伪代码如下
管道输入/输出流
管道输入/输出流和普通的文件输入/输出流或者网络输入/输出流不同之处在于，它主要用于线程之间的数据传输，而传输的媒介为内存。
管道输入/输出流主要包括了如下4种具体实现：PipedOutputStream、PipedInputStream、PipedReader和PipedWriter，前两种面向字节，而后两种面向字符。
在下述代码所示的例子中,，创建了printThread，它用来接受main线程的输入，任何main线程的输入均通过PipedWriter写入，而printThread在另一端通过PipedReader将内容读出并打印。
public class Piped {
public static void main(String[] args) throws IOException {
PipedWriter out = new PipedWriter();
PipedReader in = new PipedReader();
// 将输出流和输入流进行连接，否则在使用时会抛出IOException
out.connect(in);
Thread printThread = new Thread(new Print(in),"PrintThread");
printThread.start();
int receive;
try {
while ((receive = System.in.read()) != -1) {
out.write(receive);
}
} finally {
out.close();
}
}
static class Print implements Runnable {
private PipedReader in;
public Print(PipedReader in) {
this.in = in;
}
@Override
public void run() {
int receive;
try {
while ((receive = in.read()) != -1 ) {
System.out.print((char) receive);
}
} catch (IOException ex) {
}
}
}
}
运行该示例，输入一组字符串，可以看到被printThread进行了原样输出。
对于Piped类型的流，必须先要进行绑定，也就是调用connect()方法，如果没有将输入/输出流绑定起来，对于该流的访问将会抛出异常。
Thread.join()的使用
如果一个线程A执行了thread.join()语句,其含义是:当前线程A等待thread线程终止之后才从thread.join()返回.线程Thread除了提供join()方法之外，还提供了join(long millis)和join(long millis,int nanos)两个具备超时特性的方法。这两个超时方法表示，如果线程thread在给定的超时时间里没有终止，那么将会从该超时方法中返回。
在下述代码清单Join.java中,创建了10个线程,编号0~9，每个线程调用前一个线程的join()方法，也就是线程0结束了，线程1才能从join()方法中返回，而线程0需要等待main线程结束。
import java.util.concurrent.TimeUnit;
public class Join {
public static void main(String[] args) throws Exception {
Thread previous = Thread.currentThread();
for (int i = 0; i < 10; i++) {
// 每个线程拥有前一个线程的引用，需要等待前一个线程终止，才能从等待中返回
Thread thread = new Thread(new Domino(previous), String.valueOf(i));
thread.start();
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;
}
@Override
public void run() {
try {
thread.join();
} catch (InterruptedException e) {
}
System.out.println(Thread.currentThread().getName() + " terminate.");
}
}
}
从上述输出可以看到，每个线程终止的前提是前驱线程的终止，每个线程等待前驱线程终止后，才从join()方法返回，这里涉及了等待/通知机制（等待前驱线程结束，接收前驱线程结束通知）。
当线程终止时,会调用自身的notifyAll()方法,会通知所有等待在该线程对象的线程.可以看到到join()方法的逻辑结构与等待/通知经典范式一致，即加锁、循环和处理逻辑3个步骤。
参考数据:<