我对线程的理解与总结

╰半橙微兮° 2022-11-25 10:14 231阅读 0赞

## 什么是线程 ##

*  线程（thread）是**操作系统能够进行运算调度的最小单位**。换句话说，**是cpu调度的最小单位**。它被包含在进程之中，**是进程中的实际运作单位**。**一条线程指的是进程中一个单一顺序的控制流**，**一个进程中可以并发多个线程，每条线程并行执行不同的任务**。
 *  现代操作系统在运行一个程序时，会为其创建一个进程。例如，启动一个Java程序，操作系统就会创建一个Java进程。
 *  **线程也叫轻量级进程**（Light Weight Process），在一个进程里可以创建多个线程，这些线程都拥有各自的计数器、堆栈和局部变量等属性，并且能够访问共享的内存变量。处理器在这些线程上高速切换，让使用者感觉到这些线程在同时执行。  
    **下面使用JMX来查看一个普通的Java程序包含哪些线程**

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

**输出结果：**  
![在这里插入图片描述][20200813210619933.png_pic_center]

**Java程序天生就是多线程程序**。

## 聊一聊-为什么要使用多线程？ ##

（1）现在我们有**更多的处理器核心**。

*  随着处理器上的核心数量越来越多，以及超线程技术的广泛运用，**现在大多数计算机都比以往更加擅长并行计算，而处理器性能的提升方式，也从更高的主频向更多的核心发展**。如何利用好处理器上的多个核心也成了现在的主要问题。  
    （2）**更快的响应时间**
 *  有时我们会编写一些较为复杂的代码（这里的复杂不是说复杂的算法，而是复杂的业务逻辑），例如，一笔订单的创建，它包括插入订单数据、生成订单快照、发送邮件通知卖家和记录货品销售数量等。用户从单击“订购”按钮开始，就要等待这些操作全部完成才能看到订购成功的结果。但是这么多业务操作，如何能够让其更快地完成呢？
 *  可以使用多线程技术。即将数据一致性不强的操作派发给其他线程处理（也可以使用消息队列），如生成订单快照、发送邮件等。这样做的好处是响应用户请求的线程能够尽可能快地处理完成，缩短了响应时间，提升了用户体验  
    （3）**更好的编程模型**
 *  Java为多线程编程提供了良好、考究并且一致的编程模型，使开发人员能够更加专注于问题的解决，即为所遇到的问题建立合适的模型，而不是绞尽脑汁地考虑如何将其多线程化。一旦开发人员建立好了模型，稍做修改总是能够方便地映射到Java提供的多线程编程模型上。

## 你知道吗？线程是有优先级的。 ##

*  操作系统分出一个个时间片，线程会分配到若干时间片，当线程的时间片用完了就会发生线程调度，并等待着下次分配。**线程分配到的时间片多少也就决定了线程使用处理器资源的多少**，而**线程优先级就是决定线程需要多或者少分配一些处理器资源的线程属性**。
 *  在Java线程中，**通过一个整型成员变量priority来控制优先级**，**优先级的范围从1~10**，在线程构建的时候**可以通过setPriority(int)方法来修改优先级**，**默认优先级是5**，**优先级高的线程分配时间片的数量要多于优先级低的线程**。设置线程优先级时，**针对频繁阻塞（休眠或者I/O操作）的线程需要设置较高优先级**，**而偏重计算（需要较多CPU时间或者偏运算）的线程则设置较低的优先级**，确保处理器不会被独占。在不同的JVM以及操作系统上，线程规划会存在差异，有些操作系统甚至会忽略对线程优先级的设定。

## 线程的状态 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyaXN0amNqZG5jZw_size_16_color_FFFFFF_t_70_pic_center]  
线程状态：初始状态，运行状态，阻塞状态，等待状态，超时等待状态，终止状态。

*  **线程在自身的生命周期中，并不是固定地处于某个状态，而是随着代码的执行在不同的状态之间进行切换**，Java线程状态变迁如图：

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

可以看到，线程创建之后，调用start()方法开始运行。当线程执行wait()方法之  
后，线程进入**等待状态**。进入等待状态的线程需要依靠其他线程的通知才能够返回到**运行状态**，而**超时等待状态**相当于在等待状态的基础上增加了超时限制，也就是超时时间到达时将会返回到运行状态。当线程调用同步方法时，在没有获取到锁的情况下，线程将会进入到**阻塞状态**。线程在执行Runnable的run()方法之后将会进入到**终止状态**。

## Daemon线程 ##

Daemon线程是一种支持型线程，因为它主要被用作程序中后台调度以及支持性工作。这意味着，**当一个Java虚拟机中不存在非Daemon线程的时候，Java虚拟机将会退出**。**可以通过调用Thread.setDaemon(true)将线程设置为Daemon线程**。  
**举个例子：这个Daemon线程就相当于战时医院，如果打仗时候，兵全挂了，那么战时医院也就没有存在的意义，也就撤了。**

## 启动和终止线程 ##

*  通过调用线程的**start()方法进行启动**，随着**run()方法的执行完毕，线  
    程也随之终止**，大家对此一定不会陌生，下面将详细介绍线程的启动和终止。

**构造线程**

*  在运行线程之前首先要构造一个线程对象，线程对象在构造的时候需要提供线程所需要的属性，如线程所属的线程组、线程优先级、是否是Daemon线程等信息。代码清单所示的代码摘自java.lang.Thread中对线程进行初始化的部分。

private void init(ThreadGroup g, Runnable target, String name,long stackSize,
                          AccessControlContext acc) { 
            if (name == null) { 
                throw new NullPointerException("name cannot be null");
            }
            // 当前线程就是该线程的父线程
            Thread parent = currentThread();
            this.group = g;
            // 将daemon、priority属性设置为父线程的对应属性
            this.daemon = parent.isDaemon();
            this.priority = parent.getPriority();
            this.name = name.toCharArray();
            this.target = target;
            setPriority(priority);
            // 将父线程的InheritableThreadLocal复制过来
            if (parent.inheritableThreadLocals != null)
                this.inheritableThreadLocals=ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
            // 分配一个线程ID
            tid = nextThreadID();
        }

一个**新构造的线程对象是由其parent线程来进行空间分配的**，而child线程继承了parent是否为Daemon、优先级和加载资源的contextClassLoader以及可继承的ThreadLocal，同时还**会分配一个唯一的ID来标识这个child线程**。至此，一个能够运行的线程对象就初始化好了，**在堆内存中等待着运行**。

**启动线程**

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

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

**理解中断**

*  中断可以理解为线程的一个标识位属性，它表示一个运行中的线程是否被其他线程进行了中断操作。**中断好比其他线程对该线程打了个招呼，其他线程通过调用该线程的interrupt() 方法对其进行中断操作**。
 *  线程通过检查自身是否被中断来进行响应，线程**通过方法isInterrupted()来进行判断是否被中断，也可以调用静态方法Thread.interrupted()对当前线程的中断标识位进行复位**。如果该**线程已经处于终结状态**，**即使该线程被中断过**，在调用该线程对象的isInterrupted()时**依旧会返回false**。
 *  从Java的API中可以看到，许多声明抛出InterruptedException的方法（例如Thread.sleep(long millis)方法）这些方法在抛出InterruptedException之前，**Java虚拟机会先将该线程的中断标识位清除，然后抛出InterruptedException，此时调用isInterrupted()方法将会返回false**。

**过期的suspend()、resume()和stop()**

*  大家对于CD机肯定不会陌生，如果把它播放音乐比作一个线程的运作，那么对音乐播放做出的**暂停、恢复和停止操作对应在线程Thread的API就是suspend()、resume()和stop()**。  
    代码实现：**创建了一个线程PrintThread，它以1秒的频率进行打印，而  
    主线程对其进行暂停、恢复和停止操作**。

public class Deprecated { 
        public static void main(String[] args) throws Exception { 
            DateFormat format = new SimpleDateFormat("HH:mm:ss");
            Thread printThread = new Thread(new Runner(), "PrintThread");
            printThread.setDaemon(true);
            printThread.start();
            TimeUnit.SECONDS.sleep(3);
    // 将PrintThread进行暂停，输出内容工作停止
            printThread.suspend();
            System.out.println("main suspend PrintThread at " + format.format(new Date()));
            TimeUnit.SECONDS.sleep(3);
    // 将PrintThread进行恢复，输出内容继续
            printThread.resume();
            System.out.println("main resume PrintThread at " + format.format(new Date()));
            TimeUnit.SECONDS.sleep(3);
    // 将PrintThread进行终止，输出内容停止
            printThread.stop();
            System.out.println("main stop PrintThread at " + format.format(new Date()));
            TimeUnit.SECONDS.sleep(3);
        }
        static class Runner implements Runnable { 
            @Override
            public void run() { 
                DateFormat format = new SimpleDateFormat("HH:mm:ss");
                while (true) { 
                    System.out.println(Thread.currentThread().getName() + " Run at " +
                            format.format(new Date()));
                    SleepUtils.second(1);
                }
            }
        }
    }

**输出结果：**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyaXN0amNqZG5jZw_size_16_color_FFFFFF_t_70]  
**安全地终止线程**

*  在4.2.3节中提到的中断状态是线程的一个标识位，而**中断操作是一种简便的线程间交互方式**，而**这种交互方式最适合用来取消或停止任务**。**除了中断以外，还可以利用一个boolean变量来控制是否需要停止任务并终止该线程**。

**代码实现：创建了一个线程CountThread，它不断地进行变量累加，而主线程尝试对其进行中断操作和停止操作。**

public class Shutdown { 
        public static void main(String[] args) throws Exception { 
            Runner one = new Runner();
            Thread countThread = new Thread(one, "CountThread");
            countThread.start();
    		// 睡眠1秒，main线程对CountThread进行中断，使CountThread能够感知中断而结束
            TimeUnit.SECONDS.sleep(1);
            countThread.interrupt();
            Runner two = new Runner();
            countThread = new Thread(two, "CountThread");
            countThread.start();
    		// 睡眠1秒，main线程对Runner two进行取消，使CountThread能够感知on为false而结束
            TimeUnit.SECONDS.sleep(1);
            two.cancel();
        }
        private static class Runner implements Runnable { 
            private long i;
            private volatile boolean on = true;
            @Override
            public void run() { 
                while (on && !Thread.currentThread().isInterrupted()){ 
                    i++;
                }
                System.out.println("Count i = " + i);
            }
            public void cancel() { 
                on = false;
            }
        }
    }

**输出结果：**  
![在这里插入图片描述][20200807232012874.png]

*  main线程通过中断操作和cancel()方法均可使CountThread得以终止。
 *  这种通过标识位或者中断操作的方式能够使线程**在终止时有机会去清理资源，而不是武断地将线程停止，因此这种终止线程的做法显得更加安全和优雅**。

## **线程间通信** ##

*  **volatile和synchronized关键字**  
    https://blog.csdn.net/fristjcjdncg/article/details/107834344  
    具体详见：
    
     *  [volatile的内存语义][volatile]
     *  [volatile的应用以及底层实现原理][volatile 1]
     *  [synchronized的实现原理与应用][synchronized]
 *  **等待/通知机制**
    
     *  一个线程修改了一个对象的值，而另一个线程感知到了变化，然后进行相应的操作，整个过程开始于一个线程，而最终执行又是另一个线程。前者是生产者，后者就是消费者，这种模式隔离了“做什么”（what）和“怎么做”（How），在功能层面上实现了解耦，体系结构上具备了良  
        好的伸缩性，但是在Java语言中如何实现类似的功能呢？
     *  简单的办法是让消费者线程不断地循环检查变量是否符合预期，如下面代码所示，在while循环中设置不满足的条件，如果条件满足则退出while循环，从而完成消费者的工作。
     *  伪代码如下：

while (value != desire) { 
    	Thread.sleep(1000);
    } d
    doSomething();

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

*  1）**难以确保及时性**。在睡眠时，基本不消耗处理器资源，但是如果睡得过久，就不能及时  
    发现条件已经变化，也就是及时性难以保证。
 *  2）**难以降低开销**。如果降低睡眠的时间，比如休眠1毫秒，这样消费者能更加迅速地发现条件变化，但是却可能消耗更多的处理器资源，造成了无端的浪费。
 *  以上两个问题，看似矛盾难以调和，但是**Java通过内置的等待/通知机制能够很好地解决这个矛盾并实现所需的功能**。

**等待/通知的相关方法是任意Java对象都具备的，因为这些方法被定义在所有对象的超类java.lang.Object上**！  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyaXN0amNqZG5jZw_size_16_color_FFFFFF_t_70_pic_center 2]  
**等待/通知机制**，是指一个**线程A调用了对象O的wait()方法进入等待状态**，而另一个**线程B调用了对象O的notify()或者notifyAll()方法**，**线程A收到通知后从对象O的wait()方法返回，进而执行后续操作**。上述两个线程通过对象O来完成交互，而**对象上的wait()和notify/notifyAll()的关系就如同开关信号一样，用来完成等待方和通知方之间的交互工作**。

**调用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()方法返回时能够感知到通知线程对变量做出的修改。**

**管道输入/输出流**

*  **管道输入/输出流**和普通的文件输入/输出流或者网络输入/输出流不同之处在于，它**主要用于线程之间的数据传输，而传输的媒介为内存**。
 *  管道输入/输出流主要包括了如下**4种具体实现**：**PipedOutputStream、PipedInputStream、PipedReader和PipedWriter**，**前两种面向字节，而后两种面向字符**。

## Thread.join()的使用 ##

*  如果一个线程A执行了thread.join()语句，其含义是：**当前线程A等待thread线程终止之后才从thread.join()返回**。线程Thread除了提供join()方法之外，**还提供了join(long millis)和join(long millis,int nanos)两个具备超时特性的方法**。这两个超时方法表示，**如果线程thread在给定的超时时间里没有终止，那么将会从该超时方法中返回**。
 *  **创建了10个线程，编号0~9，每个线程调用前一个线程的join()方法，也就是线程0结束了，线程1才能从join()方法中返回，而线程0需要等待main线程结束**。

package Demo01;
    
    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.");
            }
        }
    }

运行结果：  
![在这里插入图片描述][20200813220246894.png_pic_center]

**ThreadLocal的使用**

*  ThreadLocal，**即线程变量，是一个以ThreadLocal对象为键、任意对象为值的存储结构。这个结构被附带在线程上，也就是说一个线程可以根据一个ThreadLocal对象查询到绑定在这个线程上的一个值**。
 *  **键值对的形式，可以通过set(T)方法来设置一个值，在当前线程下再通过get()方法获取到原先设置的值**。

[20200813210619933.png_pic_center]: /images/20221124/787e0d3075094a06ac38b66fe8243573.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyaXN0amNqZG5jZw_size_16_color_FFFFFF_t_70_pic_center]: /images/20221124/661d8f03ac0e40fa84b3e1abb1401b99.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyaXN0amNqZG5jZw_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221124/cfb66ae4cc6c4b42bb016ad7ee3e5b2c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyaXN0amNqZG5jZw_size_16_color_FFFFFF_t_70]: /images/20221124/536a86eefaf44b8aaf3319715202bbae.png
[20200807232012874.png]: /images/20221124/e0f7c18fd6ff41cd98a6c8d8078f55e9.png
[volatile]: https://blog.csdn.net/fristjcjdncg/article/details/107834344
[volatile 1]: https://blog.csdn.net/fristjcjdncg/article/details/107805805
[synchronized]: https://blog.csdn.net/fristjcjdncg/article/details/107824687
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyaXN0amNqZG5jZw_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221124/5d569434370d4eadb1b06a91e9fc9817.png
[20200813220246894.png_pic_center]: /images/20221124/09bdf1441e88429e99ee94371ff7f945.png