学习参考资料：《Java并发编程的艺术》
文章目录
1、线程的几种状态2、如何安全的终止线程3、线程间通信（重要）3.1共享内存3.2消息传递1、线程的几种状态
线程在运行的生命周期中可能处于六种状态其一：新建（初始）、就绪、运行、等待、阻塞、终止。
线程在自身的生命周期中，并不是固定地处于某个状态，而是随着代码的执行在不同的状态之间进行切换；
Java 线程状态变迁如下图所示。
2、如何安全的终止线程
在了解如何安全终止线程前，先来看一个中断操作
中断操作
中断操作是一种简便的线程间交互方式，这种方式最适合用来取消或暂停任务。
使用方法：其他线程通过调用该线程的interrupt()方法进行中断，使用isInterrupted()方法查看是否被中断。
由变量控制是否终结
除了中断以外，还可以利用一个boolean变量来控制是否需要暂停任务并终止该线程。
如下例子，两个线程分别进行变量累加操作，过两秒后通过改变go变量来进行终止操作
package com.thenie;public class Shutdown {public static void main(String[] args) throws InterruptedException {Runner one = new Runner();Runner two= new Runner();Thread a1 = new Thread(one, "A1");Thread a2 = new Thread(two, "A2");//运行a1.start();a2.start();Thread.sleep(2000);//终止a2two.goShutDown();}private static class Runner implements Runnable{private volatile boolean go=true;//终止标识符@Overridepublic void run() {int i=0;while(go && !Thread.currentThread().isInterrupted()){System.out.println(Thread.currentThread().getName()+":"+ i++);}}public void goShutDown(){go=false;}}}
3、线程间通信（重要）
线程开始运行，拥有自己的栈空间，就如同一个脚本一样，按照既定的代码一步一步地执行，直到终止。但是，每个运行中的线程，如果仅仅是孤立地运行，那么没有一点儿价值，或者说价值很少，如果多个线程能够相互配合完成工作，这将会带来巨大的价值。
线程间通信主要有两种类型共享内存和消息传递。
3.1共享内存
volatile关键字
volatile可以用来修饰字段（成员变量），每次修改过后会立刻写回主内存，并使缓存了这个变量的失效，保证了所有线程对变量访问的可见性。
synchronized关键字
synchronized可以修饰方法或者以同步块的形式来进行使用，它主要确保多个线程在同一个时刻，只能有一个线程处于方法或者同步块中，它保证了线程对变量访问的可见性和排他性。
3.2消息传递
等待/通知机制
等待/通知机制，是指一个线程A调用了对象O的wait()方法进入等待状态，而另一个线程B调用了对象O的notify()或者notifyAll()方法，线程A收到通知后从对象O的wait()方法返回，进而执行后续操作。上述两个线程通过对象O来完成交互，而对象上的wait()和notify/notifyAll()的关系就如同开关信号一样，用来完成等待方和通知方之间的交互工作。
等待/通知 的相关方法
下面这个例子以父亲可以往篮子里放苹果和香蕉，儿子只可以拿苹果，女儿只能拿香蕉为例来模拟线程通信
package com.thenie;public class Eat {//flag 0：表示苹果和香蕉都没有 1：表示苹果 2：香蕉static volatile int flag=0;static Object lock =new Object();public static void main(String[] args) {Thread sonThread = new Thread(new Son(), "儿子");Thread daughterThread = new Thread(new Daughter(), "女儿");Thread fatherThread = new Thread(new Father(), "父亲");sonThread.start();daughterThread.start();fatherThread.start();}static class Son implements Runnable{@Overridepublic void run() {while (true) {synchronized (lock) {while (flag != 1) {//条件不满足时try {lock.wait();} catch (InterruptedException e) {e.printStackTrace();}}flag = 0;System.out.println(Thread.currentThread().getName() + ":" + "吃了[苹果]");lock.notifyAll();}}}}static class Daughter implements Runnable{@Overridepublic void run() {while (true) {synchronized (lock) {while (flag != 2) {//条件不满足时try {lock.wait();} catch (InterruptedException e) {e.printStackTrace();}}flag = 0;System.out.println(Thread.currentThread().getName() + ":" + "吃了[香蕉]");lock.notifyAll();}}}}static class Father implements Runnable{@Overridepublic void run() {while (true) {synchronized (lock) {while (flag != 0) {//条件不满足时try {lock.wait();} catch (InterruptedException e) {e.printStackTrace();}}flag = (int) (Math.random() * 10) % 2 + 1;System.out.println(Thread.currentThread().getName() + ":放了" + (flag == 1 ? "[苹果]" : "[香蕉]"));lock.notifyAll();}}}}}
部分输出结果：
父亲:放了[苹果]儿子:吃了[苹果]父亲:放了[香蕉]女儿:吃了[香蕉]父亲:放了[苹果]儿子:吃了[苹果]父亲:放了[香蕉]女儿:吃了[香蕉]父亲:放了[香蕉]女儿:吃了[香蕉]父亲:放了[苹果]儿子:吃了[苹果]父亲:放了[香蕉]女儿:吃了[香蕉]
等待/通知的经典范式
从刚才的示例中可以提炼出等待/通知的经典范式，该范式分为两部分，分别针对等待方（消费者）和通知方（生产者）。
等待方遵循如下原则。
1）获取对象的锁。
2）如果条件不满足，那么调用对象的wait()方法，被通知后仍要检查条件。
3）条件满足则执行对应的逻辑。
对应的伪代码如下：
synchronized(对象) {while(条件不满足) {对象.wait();} 对应的处理逻辑}
通知方遵循如下原则。
1）获得对象的锁。
2）改变条件。
3）通知所有等待在对象上的线程。
对应的伪代码如下：
synchronized(对象){改变条件对象.notifyAll();}
管道输入/输出流
管道输入/输出流和普通的文件输入/输出流或者网络输入/输出流不同之处在于，它主要用于线程之间的数据传输，而传输的媒介为内存。
管道输入/输出流主要包括了如下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();// 将输出流和输入流进行连接，否则在使用时会抛出IOExceptionout.connect(in);Thread printThread = new Thread(new Print(in), "PrintThread");printThread.start();int receive = 0;try {while ((receive = System.in.read()) != -1) {out.write(receive);}} finally {out.close();}}static class Print implements Runnable {private final PipedReader in;public Print(PipedReader in) {this.in = in;}public void run() {int receive = 0;try {while ((receive = in.read()) != -1) {System.out.print((char) receive);}} catch (IOException ignored) {}}}}
运行该示例，输入一组字符串，可以看到被printThread进行了原样输出：
Repeat my words.Repeat my words.
Thread.join()的使用
如果一个线程 A 执行了thread.join()语句，其含义是：当前线程 A 等待 thread 线程终止之后才从thread.join()返回。
线程 Thread 除了提供 join() 方法之外，还提供了join(long millis)和join(longmillis, int nanos)两个具备超时特性的方法。这两个超时方法表示，如果线程 thread 在给定的超时时间里没有终止，那么将会从该超时方法中返回。
在下面的例子中，创建了 10 个线程，编号 0~9，每个线程调用前一个线程的 join() 方法，也就是线程 0 结束了，线程 1 才能从 join() 方法中返回，而线程 0 需要等待 main 线程结束。
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 final Thread thread;public Domino(Thread thread) {this.thread = thread;}public void run() {try {thread.join();} catch (InterruptedException ignored) {}System.out.println(Thread.currentThread().getName() + " terminate.");}}}
输出如下。
main terminate.0 terminate.1 terminate.2 terminate.3 terminate.4 terminate.5 terminate.6 terminate.7 terminate.8 terminate.9 terminate.
从上述输出可以看到，每个线程终止的前提是前驱线程的终止，每个线程等待前驱线程终止后，才从join()方法返回
ThreadLocal的使用
ThreadLocal，即线程变量，是一个以ThreadLocal对象为键、任意对象为值的存储结构。这个结构被附带在线程上，也就是说一个线程可以根据一个ThreadLocal对象查询到绑定在这个线程上的一个值。
可以通过set(T)方法来设置一个值，在当前线程下再通过get()方法获取到原先设置的值。
后面还会陆陆续续更新这系列的读书笔记，期待您的关注~~
