echo洋 echo洋

目录
并发编程：进程、线程
/  

并发编程：进程、线程

并发编程笔记

基础知识

1）程序、进程、线程、协程（纤程）； 2）线程有哪些状态； 3）进程间的通信方法、线程间的通信方法。

程序，进程，线程，协程

程序：

编译好的二进制文件，不占用资源。是含有指令和数据的文件 比如qq.exe

进程：

进程指正在运行的程序。确切的来说，当****一个程序进入内存运行，即变成一个进程，进程是处于运行过程中的程序，并且具有一定独立功能。

进程是****操作系统进行资源分配的最小单位，其中资源包括:CPU、内存空间、磁盘IO等, 同一进程中的多条线程共享该进程中的全部系统资源, 而进程和进程之间是相互独立的。

进程是程序在计算机上的一次执行活动。当你运行一个程序,你就启动了一个进程。显然,程序是死的、静态的,进程是活的、动态的。进程可以分为系统进程和用户进程。凡是用于完成操作系统的各种功能的进程就是系统进程,它们就是处于运行状态下的操作系统本身, 用户进程就是所有由你启动的进程。

线程：

线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的、能独立运行的基本单位。线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源。

现代操作系统调度的最小单元是线程，也叫轻量级进程（Light Weight Process），在一个进程里可以创建多个线程，这些线程都拥有各自的计数器、局部变量等属性，并且能够访问共享的内存变量。处理器在这些线程上高速切换，让使用者感觉到这些线程在同时执行。

线程无处不在，任何一个程序都必须要创建线程,特别是Java不管任何程序都必须启动一个main函数的主线程; Java Web开发里面的定时任务、定时器、JSP和 Servlet、异步消息处理机制,远程访问接口RM等,任何一个监听事件, onclick的触发事件等都离不开线程和并发的知识。

在 windows 中进程是不活动的，只是作为线程的容器

进程和线程的区别：

根本区别：进程是操作系统资源分配的基本单位，线程是处理器任务调度，执行的基本单位。

资源开销：每个进程都有独立的代码和数据空间（程序上下文），程序之间的切换会有较大的开销 线程可以看做轻量级的进程，同一类线程共享代码和数据空间，每个线程都有自己独立的运行栈和程序计数器，线程之间切换的开销小。

包含关系：进程基本上是相互独立的，而线程存在于进程内，是进程的一个子集。

内存分配：同一进程的线程共享本进程的地址和资源（方法区，堆），而进程之间的地址和资源是相互独立的。

//使用JMX来查看一个普通的Java程序包含哪些线程，如代码清单4-1所示。
 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());
         }
     }
 //结果：
 6==============Monitor Ctrl-Break
 5==============Attach Listener
 4==============Signal Dispatcher
 3==============Finalizer
 2==============Reference Handler
 1==============main

线程上下文切换：

在多线程编程中,线程个数一般都大于CPU个数,而每个CPU同一时刻只能被一个线程使用,为了让用户感觉多个线程是在同时执行的, CPU资源的分配采用了时间片轮转的策略,也就是给每个线程分配一个时间片,线程在时间片内占用CPU执行任务。当前线程使用完时间片后,就会处于就绪状态并让出CPU让其他线程占用,这就是上下文切换,从当前线程的上下文切换到了其他线程。那么就有一个问题,让出CPU的线程等下次轮到自己占有CPU时如何知道自己之前运行到哪里了?所以在切换线程上下文时需要保存当前线程的执行现场,当再次执行时根据保存的执行现场信息恢复执行现场。

线程上下文切换时机有:当前线程的CPU时间片使用完处于就绪状态时,当前线程被其他线程中断时。

什么是线程死锁

死锁是指两个或两个以上的线程在执行过程中,因争夺资源而造成的互相等待的现象，在无外力作用的情况下，这些线程会- -直相互等待而无法继续运行下去，如图1-2所示。

在图1-2中,线程A已经持有了资源2,它同时还想申请资源1,线程B已经持有了资源1,它同时还想申请资源2,所以线程1和线程2就因为相互等待对方已经持有的资源,而进入了死锁状态。

那么为什么会产生死锁呢?

死锁的产生****必须具备以下四个条件。

互斥条件:指线程对已经获取到的资源进行排它性使用,即该资源同时只由一个线程占用。如果此时还有其他线程请求获取该资源,则请求者只能等待,直至占有资源的线程释放该资源。

请求并持有条件:指一个线程已经持有了至少一个资源,但又提出了新的资源请求,而新资源已被其他线程占有,所以当前线程会被阻塞,但阻塞的同时并不释放自己已经获取的资源。

不可剥夺条件:指线程获取到的资源在自己使用完之前不能被其他线程抢占,只有在自己使用完毕后才由自己释放该资源。

环路等待条件:指在发生死锁时,必然存在一个线程一资源的环形链,即线程集合(TO, TI, T2, .., Tn);中的TO正在等待一个TI占用资源, T1正在等待T2占用的资源, .T正在等待已被TO占用的资源。

public class DeadLockTest2//创建资源
     private static Object resourceA = new Object ();
     private static Object resourceB = new Object ();
 public static void main (string [] args) {
     //创建线程A
     Thread threadA = new Thread (
         new Runnable(){
             public void run () synchronized (resourceA) {
             System.out.println(Thread.currentThread() + " get ResourceA");
             try {
                 Thread. sleep (1000);
             }cath (InterruptedException e) {
                 e.printstackTrace();
                 System.out.println(Thread.currentThread() + "waiting get sourceB") ;
                 synchronized (resourceB){
                     System.out.println(Thread.currentThread() + "get esourceB");
                 }
             }
         } 
       //创建线程B
      Thread threadB = new Thread (new Runnable() {
          public void run() {
              synchronized (resourceB) {System.out.printIn (Thread.currentThread() + " get ResourceB");
              try { 
                  Thread.sleep (1000);
              }catch (InterruptedException e){
                  
                  e.printStackTrace();
                  System.out.println (Thread.currentThread () + "waiting get esourceA");
               synchronized (resourceA) {System. out.println (Thread.currentThread() + "get ResourceA");
              }
           }
       });
              threadA.start();
              threadB.start();
          }
      }

如何避免死锁：

目前只有请求并持有和环路等待条件是可以被破坏的。

造成死锁的原因其实和申请资源的顺序有很大关系，使用资源申请的有序性原则就可以避免死锁，那么什么是资源申请的有序性呢?我们对上面线程B的代码进行如下修改。

让在线程B中获取资源的顺序和在线程A中获取资源的顺序保持一致,其·实资源分配有序性就是指,假如线程A和线程B都需要资源1, 2, 3,..., n时,对资源进行排序,线程A和线程B只有在获取了资源n-1时才能去获取资源n。

一些线程的方法：

Thread.sleep()的使用

Thread类中有--个静态的sleep方法，当--个执行中的线程调用了Thread的sleep方法后，调用线程会暂时让出指定时间的执行权，也就是在这期间不参与CPU的调度，但.是该线程所拥有的监视器资源，比如锁还是持有不让出的。指定的睡眠时间到了后该函数会正常返回，线程就处于就绪状态，然后参与CPU的调度，获取到CPU资源后就可以继续运行了。如果在睡眠期间其他线程调用了该线程的interrupt()方法中断了该线程,则该线程会在调用sleep方法的地方抛出InterruptedException异常而返回。

Thread.yield()的使用：

Thread类中有一个静态的yield方法,当一个线程调用yield方法时,实际就是在暗示线程调度器当前线程请求让出自己的CPU使用,但是线程调度器可以无条件忽略这个暗示。我们知道操作系统是为每个线程分配一个时间片来占有CPU的,正常情况下当一个线程把分配给自己的时间片使用完后,线程调度器才会进行下一轮的线程调度,而当一个线程调用了Thread类的静态方法yield时,是在告诉线程调度器自己占有的时间片中还没有使用完的部分自己不想使用了,这暗示线程调度器现在就可以进行下一轮的线程调度。当一个线程调用yield方法时,当前线程会让出CPU使用权,然后处于就绪状态,线程调度器会从线程就绪队列里面获取一个线程优先级最高的线程,当然也有可能会调度到刚刚让出CPU的那个线程来获取CPU执行权。

总结: sleep与yield方法的区别在于,当线程调用sleep方法时调用线程会被阻塞挂起指定的时间,在这期间线程调度器不会去调度该线程。而调用yield方法时,线程只是让出自己剩余的时间片,并没有被阻塞挂起,而是处于就绪状态,线程调度器下一次调度时就有可能调度到当前线程执行。

Thread.join()的使用

如果一个线程A执行了thread.join()语句，其含义是：当前线程A等待thread线程终止之后才从thread.join()返回（也就是线程A必须要等Thread线程执行完之后才可以继续执行）。线程Thread除了提供join()方法之外，还提供了join(long millis)和join(long millis,int nanos)两个具备超时特性的方法。这两个超时方法表示，如果线程thread在给定的超时时间里没有终止，那么将会从该超时方法中返回。

在下面代码所示的例子中，创建了10个线程，编号0~9，每个线程调用前一个线程的join()方法，也就是线程0结束了，线程1才能从join()方法中返回，而线程0需要等待main线程结束。

package com.pingfa.demo.course;
 
 /**
  * @Author: gyy
  * @Description:
  * @Date: 2021/6/7 16:43
  */
 public class Join {
 
     public static void main(String[] args) {
         Thread pre = Thread.currentThread();
         for (int i = 1; i < 10; i++) {
             Thread thread = new Thread(new JoinThread(pre),"joinThread=="+i);
             pre = thread;
             thread.start();
         }
         System.out.println(Thread.currentThread().getName()+" terminate");
     }
     static class JoinThread implements Runnable{
         private Thread last;
 
         public JoinThread(Thread last){
             this.last = last;
         }
         @Override
         public void run() {
             try {
                 last.join();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
             System.out.println(Thread.currentThread().getName()+" terminate");
         }
     }
 }
 //结果：
 main terminate
 joinThread==1 terminate
 joinThread==2 terminate
 joinThread==3 terminate
 joinThread==4 terminate
 joinThread==5 terminate
 joinThread==6 terminate
 joinThread==7 terminate
 joinThread==8 terminate
 joinThread==9 terminate

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

看一下join中的源码：

public final void join() throws InterruptedException {
         join(0);
 }
public final synchronized void join(long millis)
     throws InterruptedException {
//核心代码
         if (millis == 0) {
             while (isAlive()) {
                 wait(0);
             }
         }
     }
 

当线程终止时，会调用线程自身的notifyAll()方法，会通知所有等待在该线程对象上的线程。可以看到join()方法的逻辑结构和等待/通知经典范式一致，即加锁、循环和处理逻辑3个步骤。

  • synchronized 关键字很关键，表明此方法是线程安全的，线程进入此方法需要获取锁。 那么这里的锁是什么呢？是本线程实例对象，也就是语法上synchronized 关键字省略(this)的写法。 InterruptedException 说明此过程可以被打断，如有必要需要处理InterruptedException异常 isAlive()判断线程的存活状态，如果线程存活则是true，否则是false，也就是不能是终结态TERMINATED，是一个final 的 native方法
  • while，而不是if，这里是为了防上虚假唤醒，虚假唤醒是操作系统的权衡性能和健壮性之后的处理方案，具体参考虚假唤醒（spurious wakeup）

核心代码逻辑：

线程A调用线程B.join()方法，重载方法调用到join(long millis)方法 循环检查条件线程B.isAlive()，如果是存活状态则释放锁，线程A进入等待状态，等待线程B执行完成 为防止虚假唤醒，使用while循环方式来检查条件 如果线程B终结了，则跳出while循环，join方法执行结束，回到线程A继续执行

注意：

另外，线程A调用线程B的join方法后会被阻塞，当其他线程调用了线程A的 interrupt()方法中断了线程A时，线程A会抛出InterruptedException 异常而返回。下 面通 过一个例子来加深理解。

协程：

**协程，英文Coroutines，是一种比线程更加轻量级的存在。**正如一个进程可以拥有多个线程一样，一个线程也可以拥有多个协程。

协程的特点在于是一个线程执行，那和多线程比，协程有何优势？

最大的优势就是协程极高的执行效率。因为子程序切换不是线程切换，而是由程序自身控制，因此，没有线程切换的开销，和多线程比，线程数量越多，协程的性能优势就越明显。

第二大优势就是不需要多线程的锁机制，因为只有一个线程，也不存在同时写变量冲突，在协程中控制共享资源不加锁，只需要判断状态就好了，所以执行效率比多线程高很多。

用在generator中的yield可以一定程度上实现协程。虽然支持不完全，但已经可以发挥相当大的威力了。

来看例子： 传统的生产者-消费者模型是一个线程写消息，一个线程取消息，通过锁机制控制队列和等待，但一不小心就可能死锁。 如果改用协程，生产者生产消息后，直接通过 yield 跳转到消费者开始执行，待消费者执行完毕后，切换回生产者继续生产，效率极高：

import time
 
 def consumer():
     r = ''
     while True:
         n = yield r
         if not n:
             return
         print('[CONSUMER] Consuming %s...' % n)
         time.sleep(1)
         r = '200 OK'
 
 def produce(c):
     c.next()
     n = 0
     while n < 5:
         n = n + 1
         print('[PRODUCER] Producing %s...' % n)
         r = c.send(n)
         print('[PRODUCER] Consumer return: %s' % r)
     c.close()
 //主线程
 if __name__=='__main__':
     c = consumer()
     produce(c)
         
 //解释：
 注意到consumer函数是一个 generator（生成器），把一个consumer传入produce后：
 首先调用c.next()启动生成器；
 然后，一旦生产了东西，通过c.send(n)切换到consumer执行；
 consumer通过yield拿到消息，处理，又通过yield把结果传回；
 produce拿到consumer处理的结果，继续生产下一条消息；
 produce决定不生产了，通过c.close()关闭consumer，整个过程结束。
 整个流程无锁，由一个线程执行，produce和consumer协作完成任务，所以称为“协程”，而非线程的抢占式多任务。
 //执行结果
 [PRODUCER] Producing 1...
 [CONSUMER] Consuming 1...
 [PRODUCER] Consumer return: 200 OK
 [PRODUCER] Producing 2...
 [CONSUMER] Consuming 2...
 [PRODUCER] Consumer return: 200 OK
 [PRODUCER] Producing 3...
 [CONSUMER] Consuming 3...
 [PRODUCER] Consumer return: 200 OK
 [PRODUCER] Producing 4...
 [CONSUMER] Consuming 4...
 [PRODUCER] Consumer return: 200 OK
 [PRODUCER] Producing 5...
 [CONSUMER] Consuming 5...
 [PRODUCER] Consumer return: 200 OK

最后套用Donald Knuth的一句话总结协程的特点：“子程序就是协程的一种特例。”

协程的应用

有哪些编程语言应用到了协程呢？我们举几个栗子：

Lua语言

Lua从5.0版本开始使用协程，通过扩展库coroutine来实现。

Python语言

正如刚才所写的代码示例，python可以通过 yield/send 的方式实现协程。在python 3.5以后，async/await 成为了更好的替代方案。

Go语言

Go语言对协程的实现非常强大而简洁，可以轻松创建成百上千个协程并发执行。

Java语言

如上文所说，Java语言并没有对协程的原生支持，但是某些开源框架模拟出了协程的功能，有兴趣的小伙伴可以看一看****Kilim框架的源码：

线程简介

线程的优先级

现代操作系统基本采用时分的形式调度运行的线程，操作系统会分出一个个时间片，线程会分配到若干时间片，当线程的时间片用完了就会发生线程调度，并等待着下次分配。线程分配到的时间片多少也就决定了线程使用处理器资源的多少，而线程优先级就是决定线程需要多或者少分配一些处理器资源的线程属性。

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

package com.pingfa.demo.course;
 
 import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.TimeUnit;
 
 /**
  * @Author: gyy
  * @Description:
  * @Date: 2021/6/7 9:20
  */
 public class Priority {
     private static volatile boolean notStart = true;
     private static volatile boolean notEnd = true;
     public static void main(String[] args) throws Exception {
         List<Job> jobs = new ArrayList<Job>();
         for (int i = 0; i < 10; i++) {
             int priority = i < 5 ? Thread.MIN_PRIORITY : Thread.MAX_PRIORITY;
             Job job = new Job(priority);
             jobs.add(job);
             Thread thread = new Thread(job, "Thread:" + i);
             thread.setPriority(priority);
             thread.start();
         }
         notStart = false;
         TimeUnit.SECONDS.sleep(10);
         notEnd = false;
         for (Job job : jobs) {
             System.out.println("Job Priority : " + job.priority + " , Count : " + job.jobCount);
         }
     }
     static class Job implements Runnable {
         private int priority;
         private long jobCount;
         public Job(int priority) {
             this.priority = priority;
         }
         @Override
         public void run() {
             while (notStart) {
                 //Thread.yield() 方法，使当前线程由执行状态，变成为就绪状态，让出cpu时间，让其他或者自己的线程执行（也就是谁先抢到谁执行）
                 Thread.yield();
             }
             while (notEnd) {
                 Thread.yield();
                 jobCount++;
             }
         }
     }
 }
 //执行结果：优先级高的，count 比较高
 Job Priority : 1 , Count : 2957171
 Job Priority : 1 , Count : 3076423
 Job Priority : 1 , Count : 2992661
 Job Priority : 1 , Count : 2981865
 Job Priority : 1 , Count : 3187338
 Job Priority : 10 , Count : 3829924
 Job Priority : 10 , Count : 3766922
 Job Priority : 10 , Count : 3625486
 Job Priority : 10 , Count : 3789090
 Job Priority : 10 , Count : 3805380

线程有哪些状态

Java线程在运行的生命周期中可能处于下图所示的6种不同的状态，在给定的一个时刻，线程只能处于其中的一个状态。

状态名称说明
NEW初识状态，线程被创建但是还没有调用start()方法
RUNNABLE运行状态，java线程将操作系统中的就绪和运行两种状态笼统地称为 运行中
BLOCKED阻塞状态，表示线程阻塞与锁
WAITING等待状态，表示线程进入等待状态，进入该状态表示当前线程需要等待其他线程做出一些特定的动作（通知或中断）
TIME_WAITING超时等待状态，该状态不同于WAITING，他是可以在指定的时间自行返回的
TERMINATED终止状态，表示当前线程已经执行完毕

下面我们使用jstack工具（可以选择打开终端，键入jstack或者到JDK安装目录的bin目录下执行命令），尝试查看示例代码运行时的线程信息，更加深入地理解线程状态，示例如代码如下：

package com.pingfa.demo.course;
 
 /**
  * @Author: gyy
  * @Description:
  * @Date: 2021/6/7 10:10
  */
 public class ThreadState {
     public static void main(String[] args) {
         new Thread(new TimeWaiting(), "TimeWaitionThread").start();
         new Thread(new Waiting(),"WaitingThread").start();
         //使用两个BLocked线程，一个取锁成功，另一个阻塞
         new Thread(new Blocked(),"BlockedThread-1").start();
         new Thread(new Blocked(),"BlockedThread-2").start();
     }
     //该线程不断的进行休眠
     static class TimeWaiting implements Runnable{
         @Override
         public void run() {
             while (true){
                SleepUtils.second(100);
             }
         }
     }
     //该线程在Waiting.class实例上等待
     static class Waiting implements Runnable{
 
         @Override
         public void run() {
             while (true){
                 synchronized (Waiting.class){
                     try {
                         Waiting.class.wait();
                     }catch (InterruptedException e){
                         e.printStackTrace();
                     }
                 }
             }
         }
     }
     //该线程在Blocked.class实例后，不会释放该锁
     static class Blocked implements Runnable{
 
         @Override
         public void run() {
             synchronized(Blocked.class){
                 while (true){
                     SleepUtils.second(100);
                 }
             }
         }
     }
 }

通过jstack 查看线程的状态：

通过示例，我们了解到Java程序运行中线程状态的具体含义。线程在自身的生命周期中，并不是固定地处于某个状态，而是随着代码的执行在不同的状态之间进行切换，Java线程状态变迁如图所示：

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

注意 Java将操作系统中的运行和就绪两个状态合并称为运行状态。阻塞状态是线程阻塞在进入synchronized关键字修饰的方法或代码块（获取锁）时的状态，但是阻塞在java.concurrent包中Lock接口的线程状态却是等待状态，因为java.concurrent包中Lock接口对于阻塞的实现均使用了LockSupport类中的相关方法。

Daemon线程------守护线程

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

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

Daemon线程被用作完成支持性工作，但是在Java虚拟机退出时Daemon线程中的finally块并不一定会执行，示例如代码如下所示。

/**
  * @Author: gyy
  * @Description:
  * @Date: 2021/6/7 10:55
  */
 public class Daemon {
     public static void main(String[] args) {
         Thread thread = new Thread(new DaemonTest(), "DaemonTest");
         thread.setDaemon(true);
         thread.start();
     }
     static class DaemonTest implements Runnable{
         @Override
         public void run() {
             try {
                 SleepUtils.second(10);
             }finally {
                 System.out.println("Daemon finally run");
             }
         }
     }
 }
 //执行后 finally块中的代码并不会执行

运行Daemon程序，可以看到在终端或者命令提示符上没有任何输出。main线程（非Daemon线程）在启动了线程DaemonRunner之后随着main方法执行完毕而终止，而此时Java虚拟机中已经没有非Daemon线程，虚拟机需要退出。Java虚拟机中的所有Daemon线程都需要立即终止，因此DaemonTest立即终止，但是DaemonTest中的finally块并没有执行。

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

守护线程和用户线程的区别：

用户线程：有一个没有结束，JVM就不会结束

守护线程：一旦非守护线程全部结束，守护线程会随着JVM一起结束工作，

守护线程特点和注意点：

启动和终止线程

构造线程

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

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

启动线程

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

中断操作

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

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

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

//代码示例：
 package com.pingfa.demo.course;
 
 /**
  * @Author: gyy
  * @Description:
  * @Date: 2021/6/7 11:42
  */
 public class Interrupt {
 
     public static void main(String[] args) {
         Thread sleepThread = new Thread(new SleepThread(), "SleepThread");
         Thread busyThread = new Thread(new BusyThread(), "BusyThread");
         sleepThread.start();
         busyThread.start();
         
         SleepUtils.second(2);
         sleepThread.interrupt();
         busyThread.interrupt();
         
         SleepUtils.second(2);
         System.out.println("SleepThread:"+sleepThread.isInterrupted()); //false
         System.out.println("busyThread:"+busyThread.isInterrupted());//true
         SleepUtils.second(5);
     }
     static class SleepThread implements Runnable{
         @Override
         public void run() {
             while (true){
                 SleepUtils.second(10);
             }
         }
     }
     static class BusyThread implements Runnable{
         @Override
         public void run() {
             while(true){
             }
         }
     }
 }
 //SleepThread:false
 //busyThread:true
 //从结果可以看出，抛出InterruptedException的线程SleepThread，其中断标识位被清除了，而一直忙碌运作的线程BusyThread，中断标识位没有被清除。

安全终止线程

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

interrupt()，其他线程通过调用某个线程 A 的 interrupt()方法对其进行中断操作,本质上只是改变线程A的中断标志位由false改变成true,但是****改变线程A的中断标志位不代表线程A一定会立即停止自己的工作，如果A中没有检查中断标志位是否为true并作出相应的处理,即线程A完全没有理会这种中断请求。则其他线程调用线程A的interrupt()对线程A是毫无影响的。然而java里的线程是协作式的，而非抢占式的。正常情况下开发者会根据具体的业务需求通过对线程A检查自身的中断标志位是否被置为true来进行相关的业务操作，以此完成多线程之间的协调工作用以来高效的实现自身的业务需求。

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

package com.pingfa.demo.course;
 
 import java.util.concurrent.TimeUnit;
 
 /**
  * @Author: gyy
  * @Description:
  * @Date: 2021/6/7 11:55
  */
 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;
         }
     }
 }
 //Count i = 407222090
 //Count i = 496555320

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

进程间的通信方法、线程间的通信方法

进程间的通信

参考资料

参考资料

进程通信： 每个进程各自有不同的用户地址空间,任何一个进程的全局变量在另一个进程中都看不到，所以进程之间要交换数据必须通过内核,在内核中开辟一块缓冲区,进程A把数据从用户空间拷到内核缓冲区,进程B再从内核缓冲区把数据读走,内核提供的这种机制称为进程间通信

通信方法无法介于内核态与用户态的原因
管道（不包括命名管道）局限于父子进程间的通信。
消息队列在硬、软中断中无法无阻塞地接收数据。
信号量无法介于内核态和用户态使用。
共享内存需要信号量辅助，而信号量又无法使用。

1 匿名管道通信

匿名管道( pipe )：管道是一种半双工的通信方式，数据只能单向流动，而且只能在具有亲缘关系的进程间使用。进程的亲缘关系通常是指父子进程关系。

// 需要的头文件
 #include <unistd.h>
 
 // 通过pipe()函数来创建匿名管道
 // 返回值：成功返回0，失败返回-1
 // fd参数返回两个文件描述符
 // fd[0]指向管道的读端，fd[1]指向管道的写端
 // fd[1]的输出是fd[0]的输入。
 int pipe (int fd[2]);

通过匿名管道实现进程间通信的步骤如下：

父进程创建管道，得到两个⽂件描述符指向管道的两端

父进程fork出子进程，⼦进程也有两个⽂件描述符指向同⼀管道。

父进程关闭fd[0],子进程关闭fd[1]，即⽗进程关闭管道读端,⼦进程关闭管道写端（因为管道只支持单向通信）。⽗进程可以往管道⾥写,⼦进程可以从管道⾥读,管道是⽤环形队列实现的,数据从写端流⼊从读端流出,这样就实现了进程间通信。

2 高级管道通信

高级管道(popen)：将另一个程序当做一个新的进程在当前程序进程中启动，则它算是当前程序的子进程，这种方式我们成为高级管道方式。

3 有名管道通信

有名管道 (named pipe) ： 有名管道也是半双工的通信方式，但是它允许无亲缘关系进程间的通信。

4 消息队列通信

消息队列( message queue ) ： 消息队列是由消息的链表，存放在内核中并由消息队列标识符标识。消息队列克服了信号传递信息少、管道只能承载无格式字节流以及缓冲区大小受限等缺点。

5 信号量通信

信号量( semophore ) ： 信号量是一个计数器，可以用来控制多个进程对共享资源的访问。它常作为一种锁机制，防止某进程正在访问共享资源时，其他进程也访问该资源。因此，主要作为进程间以及同一进程内不同线程之间的同步手段。

6 信号

信号 ( sinal ) ： 信号是一种比较复杂的通信方式，用于通知接收进程某个事件已经发生。

7 共享内存通信

共享内存( shared memory ) ：共享内存就是映射一段能被其他进程所访问的内存，这段共享内存由一个进程创建，但多个进程都可以访问。共享内存是最快的 IPC 方式，它是针对其他进程间通信方式运行效率低而专门设计的。它往往与其他通信机制，如信号两，配合使用，来实现进程间的同步和通信。

共享内存是最快的进程间通讯的方式

  • 原因：相对于其他几种方式，共享内存直接在进程的虚拟地址空间进行操作，不再通过执行进入内核的系统调用来传递彼此的数据

8 套接字通信

套接字( socket ) ： 套接口也是一种进程间通信机制，与其他通信机制不同的是，它可用于不同机器间的进程通信

线程间的通信

volatile和synchronized

volatile关键字

Java支持多个线程同时访问一个对象或者对象的成员变量，由于****每个线程可以拥有这个变量的拷贝（虽然对象以及成员变量分配的内存是在共享内存中的，但是每个执行的线程还是可以拥有一份拷贝，这样做的目的是加速程序的执行，这是现代多核处理器的一个显著特性），所以程序在执行过程中，一个线程看到的变量并不一定是最新的。

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

举个例子，定义一个表示程序是否运行的成员变量boolean on=true，那么另一个线程可能对它执行关闭动作（on=false），这里涉及多个线程对变量的访问，因此需要将其定义成为volatile boolean on＝true，这样其他线程对它进行改变时，可以让所有线程感知到变化，因为所有对on变量的访问和修改都需要以共享内存为准。但是，过多地使用volatile是不必要的，因为它****会降低程序执行的效率。

volatile的内存语义和synchronized有相似之处，具体来说就是，当线程写入了volatile 变量值时就等价于线程退出synchronized同步块(把写入工作内存的变量值同步到主内存)，读取volatile变量值时就相当于进入同步块(先清空本地内存变量值，再从主内存获取最新值)。

volatile 虽然提供了可见性保证，但并不保证操作的原子性。那么一-般在什么时候才使用volatile 关键字呢?

●写入变量值不依赖变量的当前值时。因为如果依赖当前值，将是获取一计算一写入三步操作，这三步操作不是原子性的，而volatile不保证原子性。 ●读写变量值时没有加锁。因为加锁本身已经保证了内存可见性，这时候不需要把变量声明为volatile的。

关键字synchronized:

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

示例使用了同步块和同步方法，通过使用javap工具查看生成的class文件信息来分析synchronized关键字的实现细节，示例如下。

在Synchronized.class同级目录执行javap–v Synchronized.class，部分相关输出如下所示：

**上面class信息中，对于同步块的实现使用了monitor enter和monitor exit指令，而同步方法则是依靠方法修饰符上的ACC_SYNCHRONIZED来完成的。无论采用哪种方式，**其本质是对一个对象的监视器（monitor）进行获取，而这个获取过程是排他的，也就是同一时刻只能有一个线程获取到由synchronized所保护对象的监视器。

任意一个对象都拥有自己的监视器，当这个对象由同步块或者这个对象的同步方法调用时，执行方法的线程****必须先获取到该对象的监视器才能进入同步块或者同步方法，而没有获取到监视器（执行该方法）的线程将会被阻塞在同步块和同步方法的入口处，进入BLOCKED状态。

从图4-2中可以看到，任意线程对Object（Object由synchronized保护）的访问，首先要获得Object的监视器。如果获取失败，线程进入同步队列，线程状态变为BLOCKED。当访问Object的前驱（获得了锁的线程）释放了锁，则该释放操作唤醒阻塞在同步队列中的线程，使其重新尝试对监视器的获取。

等待/通知机制

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

简单的办法是让消费者线程不断地循环检查变量是否符合预期，如下面代码所示，在while循环中设置不满足的条件，如果条件满足则退出while循环，从而完成消费者的工作。

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

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

  1. 难以确保及时性。在睡眠时，基本不消耗处理器资源，但是如果睡得过久，就不能及时发现条件已经变化，也就是及时性难以保证。
  2. 难以降低开销。如果降低睡眠的时间，比如休眠1毫秒，这样消费者能更加迅速地发现条件变化，但是却可能消耗更多的处理器资源，造成了无端的浪费。

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

等待/通知的相关方法是任意Java对象都具备的，因为这些方法被定义在所有对象的超类java.lang.Object上，方法和描述如表4-2所示。

package com.pingfa.demo.course;
 
 import java.text.SimpleDateFormat;
 import java.util.Date;
 /**
  * @Author: gyy
  * @Description:
  * @Date: 2021/6/7 15:38
  */
 public class WaitNotifyTest {
     static boolean flag = true;
     static Object lock = new Object();
 
     public static void main(String[] args) {
         Thread waitThread = new Thread(new Wait(), "WaitThread");
         waitThread.start();
         SleepUtils.second(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) {//这里不可以使用if，因为当前线程并不没有一直在循环，而是进入等待队列
                     try {
                         System.out.println(Thread.currentThread() + " flag is true. wait @ " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
                         //进入等待队列，等待通知，不会一直循环判断
                         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()));
                 flag = false;
                 lock.notify();
                 SleepUtils.second(5);
             }
             //再次加锁
             synchronized(lock){
                 System.out.println(Thread.currentThread()+" hold lock again. sleep @ "+new SimpleDateFormat("HH:mm:ss").format(new Date()));
                 SleepUtils.second(5);
             }
         }
     }
 }
 //结果：
 Thread[WaitThread,5,main] flag is true. wait @ 16:02:21
 Thread[NotifyThread,5,main] hold lock. notify @ 16:02:22
 Thread[NotifyThread,5,main] hold lock again. sleep @ 16:02:27
 Thread[WaitThread,5,main] flag is false. running @ 16:02:32

上述第3行和第4行输出的顺序可能会互换，而上述例子主要说明了调用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-3中，WaitThread首先获取了对象的锁，然后调用对象的wait()方法，从而放弃了锁并进入了对象的等待队列WaitQueue中，进入等待状态。由于WaitThread释放了对象的锁，

NotifyThread随后获取了对象的锁，并调用对象的notify()方法，将WaitThread从WaitQueue移到SynchronizedQueue中，此时WaitThread的状态变为阻塞状态。NotifyThread释放了锁之后，WaitThread再次获取到锁并从wait()方法返回继续执行。

wait()和sleep()的区别

sleep() sleep() 方法是线程类（Thread）的静态方法，让调用线程进入睡眠状态，让出执行机会给其他线程，等到休眠时间结束后，线程进入就绪状态和其他线程一起竞争cpu的执行时间。 因为sleep() 是static静态的方法，他不能改变对象的机锁，当一个synchronized块中调用了sleep() 方法，线程虽然进入休眠，但是对象的机锁没有被释放，其他线程依然无法访问这个对象。

wait()

wait()是Object类的方法，当一个线程执行到wait方法时，它就进入到一个和该对象相关的等待池，同时释放对象的机锁，使得其他线程能够访问，可以通过notify，notifyAll方法来唤醒等待的线程

等待/通知的经典范式

该范式分为两部分，分别针对等待方（消费者）和通知方（生产者）；

等待方遵循如下原则。

  1. 获取对象的锁。
  2. **如果条件不满足，那么调用对象的wait()方法，那么就从RUNNABLE到WAITING，**被通知后仍要检查条件。
  3. 条件满足则执行对应的逻辑。

对应的伪代码如下。

/**
 * 用if为啥不行
      * 1：首先一点我们要搞清楚 wait操作会释放锁
      * 2：想想这种情况,当一个生产者线程执行的时候条件不满足 就会发生阻塞 
	这时候释放出锁 这时候又一个生产线程进来又会被wait住.然后一个消费者进来，消费了一个 但	
	是notifyall 将所有的线程都解开了 。
	那两个生产者线程就会直接运行if后面的东西并没有被拉回来重新判断一下。
	这个两个生产者线程在同步队列中依次执行，在执行的时候会直接执行if后的语句，
	那么就可能造成条件不满足的情况。所以用while循环。
 */
 synchronized(对象){
     while(条件不满足){
         对象.wait();
     }
     //满足了，就执行接下来的逻辑
 }

通知方遵循如下原则。

  1. 获得对象的锁。
  2. 改变条件。
  3. 通知所有等待在对象上的线程。被通知的线程由WAITING到BLOAKED。

对应伪代码：

synchronized(对象){
     改变条件
     对象.notifyAll();
 }

示例：有两个线程做事，发现条件不满足就会等待，另一个线程执行notifyAll()会唤醒这两个线程，但是可能只有一个线程的条件满足了，如果不使用while那么就会造成条件没有满足而去做另一件事了。

static final Object ROOM = new Object();
    static boolean hasCigarette = false;
    static boolean hasTakeout = false;

    public static void main(String[] args) {
        new Thread(() -> {
            synchronized (ROOM) {
                log.debug("有烟没？[{}]", hasCigarette);
                while (!hasCigarette) {
                    log.debug("没烟，先歇会！");
                    try {
                        ROOM.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                log.debug("有烟没？[{}]", hasCigarette);
                if (hasCigarette) {
                    log.debug("可以开始干活了");
                }
            }
        }, "小南").start();

        new Thread(() -> {
            synchronized (ROOM) {
                log.debug("外卖有没？[{}]", hasTakeout);
                while (!hasTakeout) {
                    log.debug("没外卖，先歇会！");
                    try {
                        ROOM.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                log.debug("有外卖没？[{}]", hasTakeout);
                if (hasTakeout) {
                    log.debug("可以开始干活了");
                }
            }
        }, "小女").start();
        try {
            Thread.sleep( 1000 );
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(() -> {
            synchronized (ROOM) {
                hasCigarette = true;
                log.debug("烟到了噢！");
                ROOM.notifyAll();
            }
        }, "送烟的").start();

    }

管道输入 / 输出流

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

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

看下面例子中，创建了printThread，它用来接受main线程的输入，任何main线程的输入均通过PipedWriter写入，而printThread 在另一端通过 PipedReader 将内容读出并打印。

package com.pingfa.demo.course;
 
 import java.io.IOException;
 import java.io.PipedReader;
 import java.io.PipedWriter;
 
 /**
  * @Author: gyy
  * @Description:
  * @Date: 2021/6/7 16:31
  */
 public class Piped {
     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;
         }
         @Override
         public void run() {
             int receive = 0;
             try {
                 while ((receive = in.read()) != -1) {
                     System.out.print((char) receive);
                 }
             } catch (IOException ex) {
                 ex.printStackTrace();
             }
         }
     }
 }

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

ThreadLocal的使用

介绍：

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

ThreadLocal用于保存某个线程共享变量：对于同一个static ThreadLocal，不同线程只能从中get，set，remove自己的变量，而不会影响其他线程的变量。

  1. ThreadLocal.get: 获取ThreadLocal中当前线程共享变量的值。
  2. ThreadLocal.set: 设置ThreadLocal中当前线程共享变量的值。
  3. ThreadLocal.remove: 移除ThreadLocal中当前线程共享变量的值。
  4. ThreadLocal.initialValue: ThreadLocal没有被当前线程赋值时或当前线程刚调用remove方法后调用get方法，返回此方法值。
使用：
/**
  * ThreadLocal用法
  * @author coshaho
  *
  */
 public class MyThreadLocal
 {
     private static final ThreadLocal<Object> threadLocal = new ThreadLocal<Object>(){
         /**
          * ThreadLocal没有被当前线程赋值时或当前线程刚调用remove方法后调用get方法，返回此方法值
          */
         @Override
         protected Object initialValue()
         {
             System.out.println("调用get方法时，当前线程共享变量没有设置，调用initialValue获取默认值！");
             return null;
         }
     };
      
     public static void main(String[] args)
     {
         new Thread(new MyIntegerTask("IntegerTask1")).start();
         new Thread(new MyStringTask("StringTask1")).start();
         new Thread(new MyIntegerTask("IntegerTask2")).start();
         new Thread(new MyStringTask("StringTask2")).start();
     }
      
     public static class MyIntegerTask implements Runnable
     {
         private String name;
          
         MyIntegerTask(String name)
         {
             this.name = name;
         }
  
         @Override
         public void run()
         {
             for(int i = 0; i < 5; i++)
             {
                 // ThreadLocal.get方法获取线程变量
                 if(null == MyThreadLocal.threadLocal.get())
                 {
                     // ThreadLocal.et方法设置线程变量
                     MyThreadLocal.threadLocal.set(0);
                     System.out.println("线程" + name + ": 0");
                 }
                 else
                 {
                     int num = (Integer)MyThreadLocal.threadLocal.get();
                     MyThreadLocal.threadLocal.set(num + 1);
                     System.out.println("线程" + name + ": " + MyThreadLocal.threadLocal.get());
                     if(i == 3)
                     {
                         MyThreadLocal.threadLocal.remove();
                     }
                 }
                 try
                 {
                     Thread.sleep(1000);
                 }
                 catch (InterruptedException e)
                 {
                     e.printStackTrace();
                 }
             }  
         }
          
     }
      
     public static class MyStringTask implements Runnable
     {
         private String name;
          
         MyStringTask(String name)
         {
             this.name = name;
         }
  
         @Override
         public void run()
         {
             for(int i = 0; i < 5; i++)
             {
                 if(null == MyThreadLocal.threadLocal.get())
                 {
                     MyThreadLocal.threadLocal.set("a");
                     System.out.println("线程" + name + ": a");
                 }
                 else
                 {
                     String str = (String)MyThreadLocal.threadLocal.get();
                     MyThreadLocal.threadLocal.set(str + "a");
                     System.out.println("线程" + name + ": " + MyThreadLocal.threadLocal.get());
                 }
                 try
                 {
                     Thread.sleep(800);
                 }
                 catch (InterruptedException e)
                 {
                     e.printStackTrace();
                 }
             }
         }
          
     }
 }
实现原理：

ThreadLocal 相关类结构：

//Thread类中：
/* 
 ThreadLocal values pertaining to this thread. This map is maintained
 * by the ThreadLocal class. */
ThreadLocal.ThreadLocalMap threadLocals = null;

/*
     * InheritableThreadLocal values pertaining to this thread. This map is
     * maintained by the InheritableThreadLocal class.
     */
ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;

由该图可知, Thread类中有一个threadLocals和一个inheritableThreadLocals,它们都是ThreadLocalMap类型的变量,而ThreadLocalMap是一个定制化的Hashmap。在默认情况下,每个线程中的这两个变量都为null,只有当前线程第一次调用ThreadLocal的set或者get方法时才会创建它们。

其实每个线程的本地变量不是存放在ThreadLocal实例里面,而是****存放在调用线程的threadLocals变量里面。也就是说, ThreadLocal类型的本地变量存放在具体的线程内存空间中。ThreadLocal就是一个工具壳,它通过set方法把value值放入调用线程的threadLocals里面并存放起来,当调用线程调用它的get方法时,再从当前线程的threadLocals变量里面将其拿出来使用。如果调用线程一直不终止,那么这个本地变量会一直存放在调用线程的threadLocals变量里面,所以当不需要使用本地变量时可以通过调用ThreadLocal变量的remove方法,从当前线程的threadLocals里面删除该本地变量。另外, Thread里面的threadLocals为何被设计为map结构?很明显是因为每个线程可以关联多个ThreadLocal变量。

下面简单分析ThreadLocal 的 set get remove 方法的实现逻辑

/**
      * Sets the current thread's copy of this thread-local variable
      * to the specified value.  Most subclasses will have no need to
      * override this method, relying solely on the {@link #initialValue}
      * method to set the values of thread-locals.
      *
      * @param value the value to be stored in the current thread's copy of
      *        this thread-local.
      */
     public void set(T value) {
         //(1)获取当前线程
         Thread t = Thread.currentThread();
         //(2）将当前线程作为key，去查找对应的线程变量，找到则设置
         ThreadLocalMap map = getMap(t);
         if (map != null)
             map.set(this, value);
         else{
             //(3)第一次调用就创建当前线程对应的HashMap
              createMap(t, value);
         }
     }
     /*代码(1)首先获取调用线程,然后使用当前线程作为参数调用getMap(t)方法,getMap(Thread t)的代码如下。

可以看到, getMap(t)的作用是获取线程自己的变量threadLocals, threadlocal变量被绑定到了线程的成员变量上。如果getMap(t)的返回值不为空,则把value值设置到threadLocals中,也就是把当前·变量值放入当前线程的内存变量threadLocals中。threadLocals是一个HashMap结构,其中key就是当前ThreadLocal的实例对象引用, value是通过set方法传递的值。

**/

ThreadLocalMap getMap(Thread t) {
         return t.threadLocals;
     }
 /*
 如果getMap(t)返回空值则说明是第一次调用set方法,这时创建当前线程的threadLocals变量。下面来看createMap(t, value)做什么。  创建了threadLocals 变量
 **/
     void createMap(Thread t, T firstValue) {
         t.threadLocals = new ThreadLocalMap(this, firstValue);
     }
 

/**
      * Returns the value in the current thread's copy of this
      * thread-local variable.  If the variable has no value for the
      * current thread, it is first initialized to the value returned
      * by an invocation of the {@link #initialValue} method.
      *
      * @return the current thread's value of this thread-local
      */
     public T get() {
         Thread t = Thread.currentThread();
         ThreadLocalMap map = getMap(t);
         if (map != null) {
             //不为null 直接返回数据
             ThreadLocalMap.Entry e = map.getEntry(this);
             if (e != null) {
                 @SuppressWarnings("unchecked")
                 T result = (T)e.value;
                 return result;
             }
         }
         //为空 那么则初始化当前线程的threadLocals成员交量
         return setInitialValue();
     }
 //首先获取当前线程实例,如果当前线程的threadLocals变量不为null,
//则直·接返回当前线程绑定的本地变量,否则执行代码进行初始化。setInitialValue)的代码如下。
/**
      * Variant of set() to establish initialValue. Used instead
      * of set() in case user has overridden the set() method.
      *
      * @return the initial value
      */
     private T setInitialValue() {
         T value = initialValue();
         Thread t = Thread.currentThread();
         ThreadLocalMap map = getMap(t);
         if (map != null)
             map.set(this, value);
         else
             createMap(t, value);
         return value;
     }
     protected T initialValue() {
         return null;
     }
 

public void remove() {
          ThreadLocalMap m = getMap(Thread.currentThread());
          if (m != null)
              m.remove(this);
      }
 //如以上代码所示,如果当前线程的threadLocals变量不为空,则删除当前线程中指定ThreadLocal实例的本地变量。

总结: 如图1-6所示,在每个线程内部都有一个名为threadLocals的成员变量,该变量的类型为HashMap,其中key为我们定义的ThreadLocal变量的this引用, value则为我们使用set方法设置的值。每个线程的本地变量存放在线程自己的内存变量threadLocals中如果当前线程一直不消亡,那么这些本地变量会一直存在,所以可能会造成内存溢出,因此使用完毕后要记得调用ThreadLocal的remove方法删除对应线程的threadLocals中的本地变量。

ThreadLocal不支持继承
package com.pingfa.demo.course;
 
 /**
  * @Author: gyy
  * @Description:
  * @Date: 2021/6/9 12:04
  */
 public class ThreadLocalTest {
     static final  ThreadLocal<String> threadLocal = new ThreadLocal<>();
 
     public static void main(String[] args) {
         threadLocal.set("main set value");
 
         new Thread(()->{
             System.out.println("testThread:"+threadLocal.get());
         },"testThread").start();
 
         System.out.println("mainThread: "+threadLocal.get());
     }
 }
 //结果：
 mainThread: main set value
 testThread:null

**也就是说，同一个ThreadLocal变量在父线程中被设置值后,**在子线程中是获取不到的。根据.上节的介绍，这应该是正常现象，因为在子线程thread里面调用get方法时当前线程为thread线程，而这里调用set方法设置线程变量的是main线程，两者是不同的线程，自然子线程访问时返回null。那么有没有办法让子线程能访问到父线程中的值?答案是有。

InheritableThreadLocal类

为了解决上面的问题（在子线程中的获取不到父线程的ThreadLocal）InheritableThreadLocal继承ThreadLocal，其提供了一个特性，就是可以让子线程可以访问到父线程中设置的本地变量。

InheritableThreadLocal 类源码：

//由以下代码可知, InheritableThreadLocal继承了ThreadLocal,并重写了三个方法。
//由代码(3)可知, InheritableThreadLocal重写了createMap方法,
//那么现在当第一次调用set方法时,创建的是当前线程的inheritableThreadLocals变量的实例而不再是threadLocals。
//由代码(2)可知,当调用getMap方法获取当前线程内部的map变量时,
//获取的是inheritableThreadLocals而不再是threadLocals.
 public class InheritableThreadLocal<T> extends ThreadLocal<T> {
     /**
      *(1)
      */
     protected T childValue(T parentValue) {
         return parentValue;
     }
     /**
      * (2)
      */
     ThreadLocalMap getMap(Thread t) {
        return t.inheritableThreadLocals;
     }
     /**
      * (3)
      */
     void createMap(Thread t, T firstValue) {
         t.inheritableThreadLocals = new ThreadLocalMap(this, firstValue);
     }

综上可知,在InheritableThreadLocal的世界里,变量inheritableThreadLocals替代了threadLocals.下面我们看一下重写的代码(1)何时执行,以及如何让子线程可以访问父线程的本地变量。这要从创建Thread的代码说起,打开Thread类的默认构造函数,代码如下

总结：InheritableThreadLocal 类通过重写代码（2）和（3） 让本地变量保存到具体线程的inheritableThreadLocals变量里面,那么线程在通过InheritableThreadLocal类实例,的set或者get方法设置变量时,就会创建当前线程的inheritableThreadLocals变量。当父线程创建子线程时,构造函数会把父线程中inheritableThreadLocals变量里面的本地变量复制一份保存到子线程的inheritableThreadLocals变量里面。

/**
  * @Author: gyy
  * @Description:
  * @Date: 2021/6/9 17:07
  */
 public class InheritableThreadLocalTest {
     static ThreadLocal<String> threadLocal = new InheritableThreadLocal<>();
 
     public static void main(String[] args) {
         threadLocal.set("Value");
 
         new Thread(()->System.out.println("child:"+threadLocal.get()),"child").start();
 
         System.out.println("main:"+threadLocal.get());
     }
 }
 //结果：
 main:Value
 child:Value

那么在什么情况下需要子线程可以获取父线程的threadlocal变量呢?情况还是蛮多的, 比如子线程需要使用存放在threadlocal变量中的用户登录信息,再比如一些中间件需要把统一的id追踪的整个调用链路记录下来。其实子线程使用父线程中的threadlocal方法有多种方式, 比如创建线程时传入父线程中的变量,并将其复制到子线程中,或者在父线程中构造一个map作为参数传递给子线程,但是这些都改变了我们的使用习惯,所以在这些情况下InheritableThreadLocal就显得比较有用。

标题：并发编程：进程、线程
作者：function001
地址：https://gyyspace.github.io/articles/2024/07/21/1721546762645.html