【多线程-从零开始-叁】线程的核心操作

一、创建一个线程-start()

start 和 run 的区别：（经典面试题）

run 描述了线程要执行的任务，也可以称为“线程的入口”
此处 start 会根据不同的系统，分别调用不同的 API，来执行系统函数，在系统内核中，创建线程（创建 PCB，加入到链表中）
创建好的新的线程，再单独来执行 run
start 的执行速度一般是很快的（创建线程，比较轻量），一旦 start 执行完毕，新线程就会开始执行，调用 start 的线程也会继续执行（main 线程）（开始兵分两路，并发执行）
调用 start 不一定非得是 main 线程调用，任何的线程都可以创建其他线程，如果系统资源充裕，就可以任意的创建线程（但线程不是越多越好）

public static void main(String[] args) {  
  
    Thread t = new Thread(() -> {  
        System.out.println("hello t");  
        Thread t2 = new Thread(() -> {  
            System.out.println("hello t2");  
        });        
        t2.start(); //hello t2  
    });    
    t.start();  //hello t
}

注意：

先执行的是 main 创建的线程，因为 main 是程序执行入口
所以先打印 hello t

一个 Thread 对象，只能调用一次 start，多次调用就会报线程状态异常

线程的状态：

由于 Java 中希望，一个 Thread 对象，只能对应到一个系统中的线程，因此就会在 start 中，根据线程状态做出判定。
如果 Thread 对象是还没有调用 start 的，此时就是一个 NEW 状态，之后就可以顺利地调用 start
如果 Thread 已经调用过 start，就会进入其他状态，
只要不是 NEW 状态，接下来执行 start 都会抛出异常

二、线程的终止（中断）

线程的终止
B 正在执行，A 想让 B 结束

其实核心就是 A 要想办法，让 B 的 run 方法执行完毕，此时 B 就自然结束了
而不是说 B 的 run 执行一半，A 直接把 B 强制结束了

1. 通过共享的标记来进行沟通

public class Demo3 {  
    public static boolean isQuit = false;  
  
    public static void main(String[] args) throws InterruptedException {  
        boolean isQuit = false;  
        Thread t = new Thread(() -> {  
            while(!isQuit){  
                System.out.println("hello thread");  
                try {  
                    Thread.sleep(1000);  
                } catch (InterruptedException e) {  
                    throw new RuntimeException(e);  
                }            
            }  
            System.out.println("t 线程执行结束");  
        });  
        t.start();  
        Thread.sleep(2000);  
        //修改 isQuit 变量，就能狗影响到 t 线程的结束了  
        System.out.println("main 线程尝试终止 t 线程");  
        isQuit = true;  
    }  
}

通过改变变量，让 t 线程跳出了 while 循环，最终线程终止

变量捕获

是 lambda 表达式 / 匿名内部类的一个语法规则
isQuit 和 lambda 定义在一个作用域中，此时 lambda 内部是可以访问到 lambda 外部（和 lambda 同一个作用）中的变量
但是 Java 的变量捕获有特殊要求，要求捕获的变量得是 final / 事实 final（虽然没有 final 修饰，但没有修改）

public class Demo3 {  
    //public static boolean isQuit = false;  
  
    public static void main(String[] args) throws InterruptedException {  
        boolean isQuit = false;  
        Thread t = new Thread(() -> {  
            while(!isQuit){  
                System.out.println("hello thread");  
                try {  
                    Thread.sleep(1000);  
                } catch (InterruptedException e) {  
                    throw new RuntimeException(e);  
                }            
            }  
            System.out.println("t 线程执行结束");  
        });  
        t.start();  
        Thread.sleep(2000);  
        //修改 isQuit 变量，就能影响到 t 线程的结束了  
        System.out.println("main 线程尝试终止 t 线程");  
        isQuit = true;  //会报错
    }  
}

将 isQuit 定义在 main 内部后

由于 isQuit 变量前后由 false 被改为 true 了，所以会报错
若将最后一行注释掉，此时 isQuit 就是一个事实 final（虽然没有 final 修饰，但没更改），isQuit 变量就会被捕获到，程序就不会报错

上面写成成员变量，就可以正常修改访问，因为走的语法是“内部类访问外部类的成员”，和“变量捕获”无关
lambda 表达式本质上是一个“函数式接口”产生的“匿名内部类”，外面写的 “class Demo3“ 就是外部类

2. 调用 interrupt 方法来通知

初始情况下 Thread 类里面有一个成员，boolean 类型的 interrupted
初始情况下，这个变量是 false，未被终止，但一旦外面的其他线程，调用一个 interrupt() 方法，就会设置上述标志位

public class Demo4 {  
    public static void main(String[] args) throws InterruptedException {  
        Thread t = new Thread(() -> {  
            //先获取到线程的引用  
            Thread currentThread = Thread.currentThread();  
            while(!currentThread.isInterrupted()){  
                System.out.println("hello thread");  
                try {  
                    Thread.sleep(1000);  
                } catch (InterruptedException e) {  
                    throw new RuntimeException(e);  
                }            
            }        
        });        
        
        t.start();  
        
        Thread.sleep(1000);  
        //在主线程中，控制 t 线程被终止，设置上述标志位  
        //将其由 false 设为 true，意味着循环就结束了，线程也就结束了  
        t.interrupt();  
    }
}

currentThread() 是 Thread 类的静态方法，可以获取到调用这个方法的线程的实例，哪个线程调用，返回的引用就只想哪个线程的实例，类似 this
lambda 的代码在编译器眼里，出现在 Thread t 上方，此时 t 还没有被定义，所以不能直接用 t 调用 isInterrupted() 方法

由于判定 isInterrupted() 和执行打印，这两个操作太快了，因此整个循环，主要的时间都是花在 sleep 上
main 调用 Interrupt 的时候，大概率 t 线程正处于 sleep 状态中，此处 Interrupt 不仅仅能设置标志位，还能把刚才这个 sleep 操作给唤醒
比如，当还在 sleep 的时候，此时 Interrupt 被调用了，此时 sleep 就会被直接唤醒，并且抛出 InterruptedException 异常
由于 catch 中的默认代再次抛出异常，但没人 catch，最终就到了 JVM 这一层，进程就直接异常终止了

综上： interrupt 不仅能设置标志位，还能唤醒 sleep

只不过由于 catch 中生成的默认代码影响了执行的结果，导致我们看起来像整个进程都结束了
为了排除干扰，我们可以把 catch 中的 throw 给干掉，换成一个打印“执行到 catch 操作”

public class Demo4 {  
    public static void main(String[] args) throws InterruptedException {  
        Thread t = new Thread(() -> {  
            //现货区到线程的引用  
            Thread currentThread = Thread.currentThread();  
            while(!currentThread.isInterrupted()){  
                System.out.println("hello thread");  
                try {  
                    Thread.sleep(1000);  
                } catch (InterruptedException e) {  
                    //throw new RuntimeException(e);   //屏蔽掉生成的默认代码干扰
                    System.out.println("执行到catch操作");  
                }            
            }        
        });  
        t.start();  
			  
        Thread.sleep(1000);  
        t.interrupt();  
    }
}

从运行结果可以看到，此时调用 interrupt 把 sleep 唤醒了，触发异常，被 catch 住了。但是虽然 catch 住了，但是循环还在执行，看起来就像标志位没被设置一样

注意：

首先，Interrupt 肯定会设置这个标志位的
其次，当 sleep 等阻塞的函数被唤醒后，就会清空刚才设置的 Interrupted 标志位，下一轮循环判定的时候，就会认为标志位没有被设置，于是循环就会继续执行
因此，如果确实想要结束循环，结束线程，就需要在 catch 中加上 return / break

清除标志位

清除标志位这个操作可以让编写 B 线程的程序员有更大的操作空间
A 希望 B 线程终止，B 收到这样的请求之后，B 需要自行决定，是否要终止或立即执行还是稍后执行 ~~~ （B 线程内部的代码决定，与其他线程无关）
如果 B 想无视 A，就直接 catch，啥都不做，B 线程仍然会继续执行。sleep 清除标志位，就可以使 B 做出这种选择，如果 sleep 不清除标志位的话，B 就势必会结束，无法写出让线程急速执行代码了
如果 B 线程想立即结束，就直接在 catch 中写上 return / break，此时 B 线程就会立即结束
如果 B 线程想要稍后再结束，就可以在 catch 中写上一些其他的逻辑（比如释放资源、清理一些数据、提交一些结果… 收尾工作）。这些逻辑完成之后，再进行 return / break

这是 JVM 内部的逻辑，需要结合 JVM 的源码才能看到这个操作

三、等待一个线程-join()

操作系统针对多个线程的执行，是一个“随机调度，抢占式执行的过程”。因为我们写代码的时候不希望是随机，希望是确定，所以期望通过一些变成手段来对这里的随机进行干预

线程等待就是在确定两个线程的“结束顺序”。因为我们无法确定两个线程调度执行的顺序，但是可以控制结束的先后顺序
让后结束的线程等待先结束的线程即可
此时后结束的线程就会进入阻塞，一直到先结束的进程真的结束了，阻塞才解除

比如现在有两个线程 A 和 B
在 A 线程中调用 B.join()，意思就是让 A 线程等 B 线程先结束，然后 A 再继续执行
此处的 B 是被等待的一方

public class Demo5 {  
    public static void main(String[] args){  
        Thread t = new Thread(() -> {  
            for (int i = 0; i < 3; i++) {  
                System.out.println("这是线程 t");  
                try {  
                    Thread.sleep(1000);  
                } catch (InterruptedException e) {  
                    throw new RuntimeException(e);  
                }            
            }            
            System.out.println("线程 t 结束");  
        });        
        t.start();  
        //让主线程等待 t 线程  
        System.out.println("main 线程开始等待");  
        try {  
            t.join();   //执行到这里，main线程阻塞等待
        } catch (InterruptedException e) {  
            throw new RuntimeException(e);  
        }   
         
    	//当 t 线程执行结束后，join才会返回，main才会继续执    
        System.out.println("main 线程等待结束");  
    }
}

 //t 线程先结束，main 线程后结束

上述代码是 main 先等待，然后 t 执行了半天才结束，此时 main 在阻塞。
如果调整一下，让 t 先结束，然后 main 才开是 join，这个时候也不会出现阻塞，因为 t 线程已经结束了，而 join 就是用来确保被等待的线程先结束，若已经结束了，join 就不必再等待了

任何的线程之间都是可以相互等待的，不是说必须得 main 线程等待别人
任何线程，也不一定是两个线程之间，一个线程可以同时等待多个别的线程，或者若干线程之间也能相互等待

public class Demo6 {  
    public static void main(String[] args) throws InterruptedException {  
        Thread t1 = new Thread(() -> {  
            for (int i = 0; i < 2; i++) {  
                System.out.println("hello t1");  
                try {  
                    Thread.sleep(1000);  
                } catch (InterruptedException e) {  
                    throw new RuntimeException(e);  
                }            
            }            
            System.out.println("t1 结束");  
        });  
        
        Thread t2 = new Thread(() -> {  
            for (int i = 0; i < 2; i++) {  
                System.out.println("hello t2");  
                try {  
                    Thread.sleep(1000);  
                } catch (InterruptedException e) {  
                    throw new RuntimeException(e);  
                }            
            }            
            System.out.println("t2 结束");  
        });        
        t1.start();  
        t2.start();  
        System.out.println("main 开始等待");  
        t1.join();  
        t2.join();  
        System.out.println("main 结束");  
    }
}

此时两个 join 都是写在 main 里面的，所以都是 main 线程等待 t1 和 t2，t1 和 t2 之间没有等待关系
若在 t2 中写 t1.join，则 t2 需要等待 t1 线程先执行完

上述 join 都是无参的，意思是“死等”，“不见不散”，被等待的线程，只要不执行完，就会持续阻塞
上述死等操作，其实不是一个好的选择，因为一旦被等待的线程代码出现了一些 bug 了，就可能使这个线程迟迟无法结束，从而使等待线程一直阻塞而无法进行其他操作
所以在实际开发中，都会设置一个“超时时间”，最多等多久，就是 join 的参数

这个精度和操作系统相关, 像 Windows, Linux 系统，线程调度开销比较大；计算机中还有一类系统——“实时操作系统”，就能把调度开销尽可能降低，开销小于一定的误差要求，从而可以做到更精确。一般用于航空航天，军事… 不过实时操作系统是舍弃了很多功能换来的实时性

四、获取当前线程引用

想在某个线程中，获取到自身的 Thread 对象的引用，就可以通过 currentThread 来获取到

public class Demo7 {  
    public static void main(String[] args) throws InterruptedException {  
        
        Thread mainThread = Thread.currentThread();  
        
        Thread t = new Thread(()->{  
            //需要在 t 中调用主线程.join  
            System.out.println("t 线程开始等待");  
            try {  
                mainThread.join();  
            } catch (InterruptedException e) {  
                throw new RuntimeException(e);  
            }            
            System.out.println("t 线程结束");  
        });        
        t.start();  
        Thread.sleep(1000);  
        System.out.println("main 线程结束");  
    }
}
//打印顺序：
//t 线程开始等待
//main 线程结束
//t 线程结束