学习参考资料:《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()方法获取到原先设置的值。
后面还会陆陆续续更新这系列的读书笔记,期待您的关注~~