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

港控/mmm° 2023-10-03 12:56 39阅读 0赞

#### 文章目录 ####

*  《Java并发编程的艺术》读后笔记-part4
 *  第四章 Java并发编程基础
 *   *  1.线程简介
     *   *  1.1什么是线程？
         *  1.2为什么要使用多线程？
         *  1.3线程优先级
         *  1.4线程的状态
         *  1.5Daemon线程
     *  2.启动和终止线程
     *   *  2.1构造线程
         *  2.2启动线程
         *  2.3理解中断
     *  3.线程间的通信
     *   *  3.1volatile和synchronized关键字
         *  3.2等待/通知机制
         *  3.3等待/通知的经典范式
         *  3.4管道输入/输出流
         *  3.5Thread.join()的使用
         *  3.6ThreadLocal的使用

## 《Java并发编程的艺术》读后笔记-part4 ##

## 第四章 Java并发编程基础 ##

### 1.线程简介 ###

#### 1.1什么是线程？ ####

现代操作系统在运行一个程序时，会为其创建一个进程。

现代操作系统调度的最小单元是线程，也叫轻量级进程。

在一个进程里可以创建多个线程，这些线程都拥有各自的计数器、堆栈和局部变量等属性，并且能够访问共享的内存变量。处理器在这些线程上高速切换，让使用者感觉到这些线程在同时执行。

一个`Java`程序从main()方法开始执行，然后按照既定的代码逻辑执行，看似没有其他线程参与，但实际上Java程序天生就是多线程程序，因为执行main()方法的是一个名称为main的线程。

下面我们使用JMX来查看一个普通的Java程序包包含哪些线程？

public class demo1Main1 {
        
        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());
            }
        }
    }

输出如下：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1OTY2NDQw_size_16_color_FFFFFF_t_70]

结论：可以看到，一个Java程序的运行不仅仅是main()方法的运行，而是main线程和多个其他线程的同时运行。

#### 1.2为什么要使用多线程？ ####

正确使用多线程，会给我们这些开发人员带来一些显著的好处。

使用多线程的原因主要有以下几点：

1.  **更多的处理核心**
    
    线程是大多数操作系统调度的基本单元，一个程序作为一个进程来运行，程序运行过程中能够创建多个线程，而一个线程在一个时刻只能运行在一个处理器核心上。
    
    一个单线程程序在运行时只能使用一个处理器核心，那么再多的处理器核心加入也无法显著提升该程序的执行效率。相反，如果该程序使用多线程技术，将计算逻辑分配到多个处理器核心上，就会显著减少程序的处理时间，并且随着更多处理器核心的加入而变得更有效率。
2.  **更快的响应时间**
    
    有时我们会编写一些较为复杂的代码（这里的复杂不是说复杂的算法，而是复杂的业务逻辑），例如，一笔订单的创建，它包括插入订单数据、生成订单快照、发送邮件通知卖家和记录货品销售数量等。用户从单击“订购”按钮开始，就要等待这些操作全部完成才能看到订购成功的结果。但是这么多业务操作，如何能够让其更快地完成呢？
    
    在上面的场景中，可以使用多线程技术，即将数据一致性不强的操作派发给其他线程处理（也可以使用消息队列），如生成订单快照、发送邮件等。这样做的好处是响应用户请求的线程能够尽可能快地处理完成，缩短了响应时间，提升了用户体验
3.  **更好的编程模型**
    
    Java为多线程编程提供了良好、考究并且一致的编程模型，使开发人员能够更加专注于问题的解决，即为所遇到的问题建立合适的模型，而不是绞尽脑汁地考虑如何将其多线程化。一旦开发人员建立好了模型，稍做修改总是能够方便地映射到Java提供的多线程编程模型上。

#### 1.3线程优先级 ####

在Java线程中，通过一个整型成员变量priority来控制优先级，优先级的范围从1~10，在线程构建的时候可以通过`setPriority(int)`方法来修改优先级，默认优先级是**5**，优先级高的线程分配时间片的数量要多于优先级低的线程。

设置线程优先级时，针对频繁阻塞（休眠或者I/O操作）的线程需要设置较高优先级，而偏重计算（需要较多CPU时间或者偏运算）的线程则设置较低的优先级，确保处理器不会被独占。

注意：**线程优先级不能作为程序正确性的依赖，因为操作系统可以完全不用理会Java线程对于优先级的设定。**

#### 1.4线程的状态 ####

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1OTY2NDQw_size_16_color_FFFFFF_t_70 1]

Java线程状态变迁图：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1OTY2NDQw_size_16_color_FFFFFF_t_70 2]

> 注意：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中等待/通知相关的方法：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1OTY2NDQw_size_16_color_FFFFFF_t_70 3]

**等待/通知机制**：是指一个线程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()方法返回时能够感知到通知线程对变量做出的修改。。

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1OTY2NDQw_size_16_color_FFFFFF_t_70 4]

#### 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));
                thread.start();
                previous = thread;
            }
            TimeUnit.SECONDS.sleep(5);
            System.out.println(Thread.currentThread().getName() + " terminate.");
        }
    
        static class Domin implements Runnable {
        
            private Thread thread;
    
            public Domin(Thread thread) {
        
                this.thread = thread;
            }
    
            @Override
            public void run() {
        
                try {
        
                    thread.join();
                } catch (InterruptedException e) {
        
                }
                System.out.println(Thread.currentThread().getName() + " terminate.");
    
            }
        }
    }

可以看出：每个线程终止的前提是前驱线程的终止，每个线程等待前驱线程终止后，才从`join()`方法返回，这里涉及了**等待/通知**机制（等待前驱线程结束，接收前驱线程结束通知）。

#### 3.6ThreadLocal的使用 ####

ThreadLocal，即**线程变量**，是一个**以`ThreadLocal`对象为键、任意对象为值的存储结构**。这个结构被附带在线程上，也就是说一个线程可以根据一个`ThreadLocal`对象查询到绑定在这个线程上的一个值。

可以通过`set(T)`方法来设置一个值，在当前线程下再通过`get()`方法获取到原先设置的值。

> 代码演示如下：

public class demo1Main2 {
        
        public static final ThreadLocal<Long> TIME_THREADLOCAL = new ThreadLocal<Long>() {
        
            protected Long initialValue() {
        
                return System.currentTimeMillis();
            }
        };
        public static final void begin() {
        
            TIME_THREADLOCAL.set(System.currentTimeMillis());
        }
        public static final long end() {
        
            return System.currentTimeMillis() - TIME_THREADLOCAL.get();
    
        }
        public static void main(String[] args) throws InterruptedException {
        
    
            demo1Main2.begin();
            TimeUnit.SECONDS.sleep(1);
            System.out.println("Cost: " + demo1Main2.end() + " mills");
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1OTY2NDQw_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/8a15a19b23d54a378d1ed05fb660ad26.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1OTY2NDQw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1OTY2NDQw_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/b2bf8dfe9e4a4374b871d43daba78e22.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1OTY2NDQw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1OTY2NDQw_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/656706c3ffec4da68b65846e97b8b5bd.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1OTY2NDQw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1OTY2NDQw_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/6900d54c4a374ad689c60218d9111070.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1OTY2NDQw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1OTY2NDQw_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/e9a91ef28a624cf8adce3379d12cc092.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1OTY2NDQw,size_16,color_FFFFFF,t_70