多线程的创建，复习匿名内部类，Thread的一些方法，以及lambda的变量捕捉,join用法

一、 

Java的Thread类表示线程

1.创建类，继承Thread重写run方法

2.创建类，实现Runnable重写run方法

3.可以继承Thread重写run基于匿名内部类

4.实现Runnable重写run基于匿名内部类

5.lamdba表达式表示run方法的内容（推荐）

6。基于Callable（以后学）

7.基于线程池（以后学）

 匿名内部类（不用看定义，看下面用法领悟）：正常建类后面大括号，这一步相当于先创建一个子类，但是这个子类是没有名字（匿名），另一方面，这类的创建是在Demo这个类里面。

下面这个写法是3号

我们要记住一个是，最重要的是写run这个是赋予了线程需要做什么工作。

public  class  Demo {
        public static void main(String[] args) throws InterruptedException {
            Thread t=new Thread(){      //匿名内部类，看上面详细解答
                @Override
                public void run() {     //子类中重写了run方法，实现了线程要干的工作
                    while(true){
                        System.out.println("hello world");
                        try {
                            Thread.sleep(3000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            };
            t.start();               //创建了该类的实例，并且是使用那个t这个引用指向。
            while (true) {
                System.out.println("love");
                Thread.sleep(1000);
            }
        }
    }

写法4

为什么括号不是封死的，因为小括号对应的是Thread构造方法的结束，new Runnable整个一段，都在构造出一个Thread的参数， 创建这个匿名内部类，通过构造方法传给Thread。

public  class  Demo {
        public static void main(String[] args) throws InterruptedException {
            Thread t=new Thread(new Runnable (){            //！！！括号不是封死的
                @Override
                public void run() {
                    while(true){
                        System.out.println("hello world");
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }   ) ;                 //！！！！！看这个小括号
            t.start();
            while (true) {
                System.out.println("love");
                Thread.sleep(1000);
            }
        }
    }

5.使用lambda（推荐的方法) 表示run方法的内容 （本质是匿名方法，这样的匿名函数，主要可以作为回调函数使用。——回调函数（合适的时候就干，不合适就选择不干。），不需要程序猿们主动去调动（需要知道函数名，才能被调动，常用场景 1.服务器开发 2.图形界面开发，用户的某个操作，触发回调），而是在合适的时机自动的被调动

Java本身不允许函数脱离类，但是lambda特例，起名叫“函数式接口”（必须只有一个方法）

类似于Lammbda这样的写法，本质上并没有新增新的语言特性，而是把以往实现的功能，换了一种更简单的方式编写。

public  class  Demo {
        public static void main(String[] args) throws InterruptedException {
            Thread t=new Thread(()->{                //也是没有右括号，在下面。
                    while(true){
                        System.out.println("hello world");
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
            });
            t.start();
            while (true) {
                System.out.println("love");
                Thread.sleep(1000);
            }
        }
    }

---

二、  

Thread就是Java,线程的代言人，系统中一个线程，对应Java中一个Thread对象

public  class  Demo {
        public static void main(String[] args) throws InterruptedException {
            Thread t=new Thread(()->{
                    while(true){
                        System.out.println("hello world");
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
            },"myThread");           //给这个进程起名字
            t.start();
            while (true) {
                System.out.println("love");
                Thread.sleep(1000);
            }
        }
    }

Thread常见ID。线程的身份标识（JVM，给设定了一个标识）

一个线程可以存好几个身份标记：

1.JVM有一个身份标记

2.pthread库（系统给程序猿提供的操作线程的API，也有一个线程的身份标识）

3.内核里面，针对线程的PCB还有身份标识

Thread常见属性

id.           getId()                            

name.     getname()

状态。     getState()           java中线程的状态和操作系统的有一定差异。

优先级     getPriority          设置获取优先级的作用不是很大，线程的调度，主要还是系统内核负责～系统的调度速度更快。

是否是后台进程   isDaemon()          

后台进程/守护进程,后台进程不影响进程结束，（创建的线程默认是前端线程）前台进程会影响到进程结束，如果前台进程没执行完，进程是不会结束的。

一个进程的所有前台线程，都执行完退出了，那么即使存在后端线程没有执行完毕，也会随着进程一起退出

setDaemon(true)   把某一个进程，设置为后端进程，这样前端线程结束，后面的也结束了

public  class  Demo {
        public static void main(String[] args) throws InterruptedException {
            int n =0;
            Thread t=new Thread(()->{
                    int m =0;
                    while(m<9){
                        System.out.println("hello world");
                        m++;
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
            },"myThread");
            t.setDaemon(true);             //设置为后端线程

            t.start();
            while (n<3) {           // 打印完事走完全部就结束了,所以一定会有这三个
               System.out.println("love");    
                n++;
                Thread.sleep(1000); 
            }
        }
    }

是否存活 isAlive

Thread对象，对应的线程（在系统内核中）是否存活。

Thread对象，并不是和系统中的线程完全一样（同生共死）的。

一般的Thread对象，先创建好，～手动调用start ，内核才真正创造出线程

消亡的时候，

可能对象，先结束了生命周期（没有引用指向这个对象）

也有可能Thread对象还在，内核中的线程把run执行完成了，就结束了。

对象的整个生命周期大致可以分为7个阶段：

创建阶段、应用阶段、不可视阶段、不可到达阶段、可收集阶段、终结阶段、与释放阶段（了解就好）

重要方法start():真正创造出线程->调用系统API完成线程创建工作（本身是一瞬间完成的，相当于是传话的小弟，“你造个线程出来”，调用API之后代码立刻执行start之后的逻辑

操作系统=内核+配套的程序

一个系统最核心的功能：

1.对下管理好各种硬件设备

2.对上，给各种程序提供稳定的运行环境

操作系统的内核（应用程序）：

创建线程，非常核心的功能，系统API，系统调用

一般情况应用，不可进入内核操作，不可进入内核的程序成为“用户态”

如果一些应用程序，能够进入后台，直接操作内核里面的一些数据结构，程序是出于“内核态”这样的程序还叫做驱动程序

---

三、  

Thread的方法 

（一个线程的run方法执行完毕，就算终止了。此时的终止此处线程，就是要想办法让run尽快执行完毕（正常不会出现run没执行完毕，突然就没了的情况）

（sleep相当于是停一会，不是说停止了）

1.程序猿们手动设置标志位，如

public static voolean isQuit=false;(写成成员变量，不会触发变量捕捉，而是内部类来访问成员变量， 看下面这个图，代码在后面，执行完isQuit=true; 线程就终止了，同时main也走完了。

public  class  Demo {
    public static boolean isQuit=false;
        public static void main(String[] args) throws InterruptedException {
            int n =0;
            Thread t=new Thread(()->{
                    int m =0;
                    while(!isQuit){
                        System.out.println("hello world");
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
            },"myThread");

            t.start();

            while (n<3) {
                System.out.println("love");
                n++;
                Thread.sleep(1000);
            }
            isQuit=true;          //手动终止
        }
    }

但是我们来看下面这个图，为什么我这样放进方法里面不可以呢？——这就源于我们lambda表达式的变量捕捉机制​​​​​​​～

lambda可以捕获外界变量，这样lambda表达式执行的时机是更靠后的，这就导致，后续真正执行lambda时候，局部变量isQuit是否可能已经被销毁了呢？

这种情况是客观存在的，让lambda去访问一个已经被销毁的变量，很明显是不合适的，lambda引入了变量捕获这样的机制～，lambda去访问一个已经被销毁的变量，但明显是不合适的，lambda引入了变量捕获这样的机制～，lambda内部看起来是直接访问外部的变量，其实本质是把外部变量给复制了一份，到lambda里面（这样就可以解决刚才的生命周期问题了）（但是捕获变量有限制的，要求是be final（如同final,就是一个变量，我们后续没有修改他的操作）  or effectively final(事实上的最终值 final修饰）

2.直接用Thread 类，给我们提供了现成标志位，不用手动, 

while(!Thread.currentThread().isInterrupted())

Thread.currentThread():的含义获取当前线程的对象Thread,提供静态方法,currentThread在哪个线程调动这个方法，就能够获取到哪个线程的引用（相当于就是t，但是不可以写t，写t是报错的）

isInterrupted()

对象内部，提供了一个标志位（boolean类型的）

true:结束

false:不结束

我们看上面的图能发现，为啥还会有异常呢？，原因就是一个线程kennel正在运行，也可能处于sleep状态，如果线程sleep的过程中，是否应该把他唤醒你？

当然了，肯定要把他唤醒，但是sleep在唤醒的同时也会自动清除前面设置的标志位，给程序猿们留下操作空间，此时要是想让线程结束，则catch之后加一个break;

sleep唤醒之后，程序猿们一般有以下几种操作方式：

1.立即停下来，立即结束线程

2.忽略终止请求，继续循环（不写break)

3.继续做点别的事情，过一会再结束线程（catch之后执行别的逻辑，最后break;)

 

public  class  Demo {

        public static void main(String[] args) throws InterruptedException {
            int n =0;
            Thread t= new Thread(()->{
                    int m =0;
                    while(!Thread.currentThread().isInterrupted()){
                        System.out.println("hello world");
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                            break;
                        }
                    }
            },"myThread");

            t.start();

            while (n<3) {
                System.out.println("love");
                n++;
                Thread.sleep(1000);
            }
           t.interrupt();
        }
    }

四、 

等待线程——join

多个线程是并发执行的，具体的执行过程，都是由操作系统复制调度的！！！，操作系统的调度线程“随机的”（当然，是我们无法确定他的先后顺序）

等待线程就是一种规划线程结束顺序的手段～ A，B两个线程，希望B先结束，A后结束，此时就可以，让A线程调用B.join方法（去等待B）

此时B线程还没结束完，A线程就会进入阻塞状态，相当于给B留下了空间，B执行完毕之后，A再从阻塞状态中恢复回来，并且继续往后执行。，如果A执行到B.join的时候，B已经执行完，那么A就不用阻塞了，直接往下执行即可,如下图，他是等待，先把t这个线程走完了，再去走下面的main.

​​​​​​​

阻塞->该代码暂时不继续执行（该进程暂时不去cpu参与调度）sleep也能让该线程阻塞，但是是有时间限制的

join是死等，知道你完事，不然他不会开始（不推荐） 产生一个新的join（里面填写时间）最大等待时间。只要我时间到了，不管你来不来，我都走了（更推荐使用，这种时间版本，留有余地。）

可以被interrupt唤醒的等待操作：

1.join

2.sleep

3.wait

 需要的自己拿着用呗

public  class  Demo {

        public static void main(String[] args) throws InterruptedException {
            int n =0;
            Thread t= new Thread(()->{
                    int m =0;
                    while(m<5){
                        System.out.println("hello world");
                        m++;
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
            },"myThread");

            t.start();
            t.join(3000);
            while (n<3) {
                System.out.println("love");
                n++;
                Thread.sleep(1000);
            }

        }
    }