《Java并发编程的艺术》读后笔记-第四章 Java并发编程基础

Java线程在运行的生命周期中可能处于6种状态，在给定的一个时刻，线程宅男处于其中一个状态，如图：

Java线程状态变迁图：

注意：Java将操作系统中的运行和就绪两个状态合并称为运行状态。

1.5Daemon线程

Daemon线程是一种支持型线程，因为它主要被用作程序中后台调度以及支持性工作。这意味着，当一个Java虚拟机中不存在非Daemon线程的时候，Java虚拟机将会退出。可以通过调用Thread.setDaemon(true)将线程设置为Daemon线程。

注意1：Daemon属性需要在启动线程之前设置，不能在启动线程之后设置。

注意2：在构建Daemon线程时，不能依靠finally块中的内容来确保执行关闭或清理资源的逻辑。

2.启动和终止线程

---

2.1构造线程

在运行线程之前首先要构造一个线程对象，线程对象在构造的时候需要提供线程所需要的属性，如线程所属的线程组、线程优先级、是否是Daemon线程等信息。

2.2启动线程

线程对象在初始化完成之后，调用start() 方法就可以启动这个线程。线程start()方法的含义是：当前线程（即parent线程）同步告知Java虚拟机，只要线程规划器空闲，应立即启动调用 start()方法的线程。

注意：启动一个线程前，最好为这个线程设置线程名称。

因为这样在使用jstack分析程序或者进行问题排查时，就会给开发人员提供一些提示，自定义的线程最好能够起个名字。

2.3理解中断

中断可以理解为线程的一个标识位属性，它表示一个运行中的线程是否被其他线程进行了中断操作。中断好比其他线程对该线程打了个招呼，其他线程通过调用该线程的interrupt()方法对其进行中断操作。

线程通过检查自身是否被中断来进行响应，线程通过方法isInterrupted()来进行判断是否被中断，也可以调用静态方法Thread.interrupted()对当前线程的中断标识位进行复位。如果该线程已经处于终结状态，即使该线程被中断过，在调用该线程对象的isInterrupted()时依旧会返回false。

从Java的API中可以看到，许多声明抛出InterruptedException的方法（例如Thread.sleep(long millis)方法）这些方法在抛出InterruptedException之前，Java虚拟机会先将该线程的中断标识位清除，然后抛出InterruptedException，此时调用isInterrupted()方法将会返回false。

我们先看一段代码来了解：

public class demo1Main2 {

public static void main(String[] args) throws Exception {

// sleepThread不停的尝试睡眠

Thread sleepThread = new Thread(new SleepRunner(), “SleepThread”);

sleepThread.setDaemon(true);

// busyThread不停的运行

Thread busyThread = new Thread(new BusyRunner(), “BusyThread”);

busyThread.setDaemon(true);

sleepThread.start();

busyThread.start();

// 休眠5秒，让sleepThread和busyThread充分运行

TimeUnit.SECONDS.sleep(5);

sleepThread.interrupt();

busyThread.interrupt();

System.out.println("SleepThread interrupted is " + sleepThread.isInterrupted());

System.out.println("BusyThread interrupted is " + busyThread.isInterrupted());

// 防止sleepThread和busyThread立刻退出

SleepUtils.second(2);

}

static class SleepRunner implements Runnable {

@Override

public void run() {

while (true) {

SleepUtils.second(10);

}

}

}

static class BusyRunner implements Runnable {

@Override

public void run() {

while (true) {

}

}

}

}

输出：

SleepThread interrupted is false

BusyThread interrupted is true

从结果可以看出，抛出InterruptedException的线程SleepThread，其中断标识位被清除了，而一直忙碌运作的线程BusyThread，中断标识位没有被清除。

3.线程间的通信

---

3.1volatile和synchronized关键字

volatile：关键字volatile可以用来修饰字段（成员变量），就是告知程序任何对该变量的访问均需要从共享内存中获取，而对它的改变必须同步刷新回共享内存，它能保证所有线程对变量访问的可见性。过多地使用volatile是不必要的，因为它会降低程序执行的效率。

synchronized：关键字synchronized可以修饰方法或者以同步块的形式来进行使用，它主要确保多个线程 在同一个时刻，只能有一个线程处于方法或者同步块中，它保证了线程对变量访问的可见性 和排他性。

3.2等待/通知机制

一个线程修改了一个对象的值，而另一个线程感知到了变化，然后进行相应的操作，整个过程开始于一个线程，而最终执行又是另一个线程。前者是生产者，后者就是消费者，这种模式隔离了“做什么”（what）和“怎么做”（How），在功能层面上实现了解耦，体系结构上具备了良好的伸缩性，但是在Java语言中如何实现类似的功能呢？

我们先看一个简单的方法，并想一下它的弊端：

while(value != desire){

Thread.sleep(1000);

}

doSomething();

上面这段伪代码在条件不满足时就睡眠一段时间，这样做的目的是防止过快的“无效”尝试，这种方式看似能够解实现所需的功能，但是却存在如下问题：

1. 难以确保及时性。在睡眠时，基本不消耗处理器资源，但是如果睡得过久，就不能及时发现条件已经变化，也就是及时性难以保证。

2. 难以降低开销。如果降低睡眠的时间，比如休眠1毫秒，这样消费者能更加迅速地发现条件变化，但是却可能消耗更多的处理器资源，造成了无端的浪费。

以上两个问题，看似矛盾难以调和，但是Java通过内置的等待/通知机制能够很好地解决这个矛盾并实现所需的功能。

Java中等待/通知相关的方法：

等待/通知机制：是指一个线程A调用了对象O的wait()方法进入等待状态，而另一个线程B调用了对象O的notify()或者notifyAll()方法，线程A收到通知后从对象O的wait()方法返回，进而执行后续操作。上述两个线程通过对象O来完成交互，而对象上的wait()和notify/notifyAll()的 关系就如同开关信号一样，用来完成等待方和通知方之间的交互工作。

我们举个栗子，代码如下：

public class demo1Main2 {

static boolean flag = true;

static Object lock = new Object();

public static void main(String[] args) throws InterruptedException {

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 {

@Override

public void run() {

// 加锁，拥有lock的Monitor

synchronized (lock) {

// 当条件不满足时，继续wait，同时释放了lock的锁

while (flag) {

System.out.println(Thread.currentThread() + " flag is true.wa@ " + new SimpleDateFormat(“HH:mm:ss”).format(new Date()));

try {

lock.wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

// 条件满足时，完成工作

System.out.println(Thread.currentThread() + "flag is false. running@ " + new SimpleDateFormat(“HH:mm:ss”).format(new Date()));

}

}

}

static class Notify implements Runnable {

@Override

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()));

lock.notifyAll();

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.wa@ 16:52:33

Thread[NotifyThread,5,main] hold lock. notify @ 16:52:34

Thread[NotifyThread,5,main]hold lock again. sleep@16:52:39

Thread[WaitThread,5,main]flag is false. running@ 16:52:44

需要注意的细节：

（1）使用wait()、notify()和notifyAll()时需要先对调用对象加锁。

（2）调用wait()方法后，线程状态由RUNNING变为WAITING，并将当前线程放置到对象的等待队列。

（3）notify()或notifyAll()方法调用后，等待线程依旧不会从wait()返回，需要调用notify()或notifAll()的线程释放锁之后，等待线程才有机会从wait()返回。

（4）notify()方法将等待队列中的一个等待线程从等待队列中移到同步队列中，而notifyAll()方法则是将等待队列中所有的线程全部移到同步队列，被移动的线程状态由WAITING变为BLOCKED。

（5）从wait()方法返回的前提是获得了调用对象的锁。

可以看出：等待/通知机制依托于同步机制，其目的就是确保等待线程从wait()方法返回时能够感知到通知线程对变量做出的修改。。

下图描述了该栗子的过程：

3.3等待/通知的经典范式

从上一节的示例中可以提炼出等待/通知的经典范式。该范式分为等待方（消费者）和通知方（生产者）两部分。

等待方遵循如下原则：

1. 获取对象的锁。

2. 如果条件不满足，那么调用对象的wait()方法，被通知后仍要检查条件。

3. 条件满足则执行对应的逻辑。

对应伪代码：

synchronized(对象){

while(条件不满足){

对象.wait();

}

对应的处理逻辑

}

通知方遵循如下原则：

1. 获得对象的锁。

2. 改变条件。

3. 通知所有等待在对象上的线程。

对应伪代码：

synchronized(对象){

改变条件

对象.notifyAll();

}

3.4管道输入/输出流

管道输入/输出流和普通的文件输入/输出流或者网络输入/输出流不同之处在于，它主要用于线程之间的数据传输，而传输的媒介为内存。

管道输入/输出流主要包括了如下4种具体实现：PipedOutputStream、PipedInputStream、 PipedReader和PipedWriter，前两种面向字节，而后两种面向字符。

public class demo1Main2 {

public static void main(String[] args) throws Exception {

PipedWriter out = new PipedWriter();

PipedReader in = new PipedReader();

// 将输出流和输入流进行连接，否则在使用时会抛出IOException

out.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 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 ex) {

}

}

}

}

运行该示例，输入一组字符串，可以看到被printThread进行了原样输出。

xppmzz

xppmzz

对于Piped类型的流，必须先要进行绑定，也就是调用connect()方法，如果没有将输入/输出流绑定起来，对于该流的访问将会抛出异常。

3.5Thread.join()的使用

如果一个线程A执行了thread.join() 语句，其含义是：当前线程A等待thread线程终止之后才从thread.join()返回。

线程Thread除了提供join()方法之外，还提供了join(long millis)和join(long millis,int nanos)两个具备超时特性的方法。这两个超时方法表示，如果线程thread在给定的超时时间里没有终止，那么将会从该超时方法中返回。

我们先看一段代码连接以下它的功能：

public class demo1Main2 {

public static void main(String[] args) throws InterruptedException {

Thread previous = Thread.currentThread();

for (int i = 0; i < 10; i++) {

// 每个线程拥有前一个线程的引用，需要等待前一个线程终止，才能从等待中返回

Thread thread = new Thread(new Domin(previous), String.valueOf(i));

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

最后

一次偶然，从朋友那里得到一份“java高分面试指南”，里面涵盖了25个分类的面试题以及详细的解析：JavaOOP、Java集合/泛型、Java中的IO与NIO、Java反射、Java序列化、Java注解、多线程&并发、JVM、Mysql、Redis、Memcached、MongoDB、Spring、Spring Boot、Spring Cloud、RabbitMQ、Dubbo 、MyBatis 、ZooKeeper 、数据结构、算法、Elasticsearch 、Kafka 、微服务、Linux。

这不，马上就要到招聘季了，很多朋友又开始准备“金三银四”的春招啦，那我想这份“java高分面试指南”应该起到不小的作用，所以今天想给大家分享一下。

请注意：关于这份“java高分面试指南”，每一个方向专题（25个）的题目这里几乎都会列举，在不看答案的情况下，大家可以自行测试一下水平 且由于篇幅原因，这边无法展示所有完整的答案解析
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！
img.cn/images/e5c14a7895254671a72faed303032d36.jpg" alt=“img” style=“zoom: 33%;” />

最后

一次偶然，从朋友那里得到一份“java高分面试指南”，里面涵盖了25个分类的面试题以及详细的解析：JavaOOP、Java集合/泛型、Java中的IO与NIO、Java反射、Java序列化、Java注解、多线程&并发、JVM、Mysql、Redis、Memcached、MongoDB、Spring、Spring Boot、Spring Cloud、RabbitMQ、Dubbo 、MyBatis 、ZooKeeper 、数据结构、算法、Elasticsearch 、Kafka 、微服务、Linux。

这不，马上就要到招聘季了，很多朋友又开始准备“金三银四”的春招啦，那我想这份“java高分面试指南”应该起到不小的作用，所以今天想给大家分享一下。

[外链图片转存中…(img-HVLHrziu-1713514247304)]

请注意：关于这份“java高分面试指南”，每一个方向专题（25个）的题目这里几乎都会列举，在不看答案的情况下，大家可以自行测试一下水平 且由于篇幅原因，这边无法展示所有完整的答案解析
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！