多线程（2）——Thread类及常见方法

构造方法

Thread(String name) //name参数给线程起名

给线程起名的目的是方便调试
给不同的线程起名字，就能在 JConsole（查看线程执行过程的文件） 看到线程对应的名字，如果不起名字，默认命名风格是 Thread-数字

例如：


在上面的代码中，main线程执行完，被销毁了，所以看不到main线程的运行
如果想要看到main，就创建一个让main线程一直运行的代码（比如创建死循环）

常见属性

获取方法           属性
getId()          ID
getName()        名称
getState()       状态
getPriority()    优先级
isDaemon()       是否后台线程
isAlive()        是否存活       线程没执行完，就是存活，isAlive为true。执行完了或还没开始为false
isInterrupted()  是否被中断

前台线程，后台线程

后台线程：线程没运行完，进程可以结束（线程不能阻止进程结束）
—— 线程不影响进程是否结束（无论有多少个后台线程，都无法阻止进程结束, 此时进程一结束，后台线程也跟着结束）
前台线程：线程没运行完，进程就不会结束（线程能阻止进程结束）
——如果有多个前台线程，就得所有的前台线程都结束，进程才结束

如：main线程和自己创建的线程就是前台线程，其余线程就是后台线程（守护线程）

要想把前台线程转为后台线程，可以调用 setDaemon()，
前提是必须在start之前set
例如：t.setDaemon(true);

默认情况下，我们自己创建的线程都是前台线程

什么时候用前台线程，什么时候用后台线程？
如果一个线程做的任务很重要，这个任务必须执行完，就一个设置为前台线程
如果一个线程做的任务无关紧要/ 周期性无期限执行（如JVM的垃圾回收机制），就应该设置为后台线程

启动一个线程——start()

调用 start 会真正调用系统中创建线程的 api
线程抛弃来后，就会自动执行到 run

⽤start⽅法,才真的在操作系统的底层创建出⼀个线程
一个线程对象只能 start一次，因为线程执行了 start 之后，就是就绪 / 阻塞 状态了，对于就绪/阻塞 下的线程，不能再次 start

中断（终止）一个线程

正常情况下，一个线程需要把入口方法执行完才能使线程结束，但是有些情况下需要让这个线程提前结束（特别是在sleep中的线程）

方法1：通过变量

public class Demo8 {
    private static boolean flag=true;
    public static void main(String[] args) throws InterruptedException {
        Thread t=new Thread(()->{
            while (flag){
                System.out.println("Thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        t.start();
        Thread.sleep(3000);
        flag=false;
        System.out.println("t线程结束");
    }
}

通过变量控制循环，达到终止线程的目的

方法2：使用 isInterrupted() —线程内置的标志位

public static void main(String[] args) {
        Thread t=new Thread(()->{
            //因为这个currentThread 方法是在后续的 t start 之后才执行的
            //Thread方法内还不知道 t 是什么
            //所以不能用 !t.isInterrupted() 作为while循环的条件
            while (Thread.currentThread().isInterrupted()){
                System.out.println("Thread");
            }
        });
        t.start();
        
        //在 main 方法中终止t,调用下面方法把线程t终止
        t.interrupt();
    }

currentThread() 是Thread类提供的一个静态方法
哪个线程调用这个方法，就返回哪个线程对象的引用

但是如果在线程中加了sleep，情况就会不一样（t 线程不会终止）
如果 t 线程正在sleep
此时main 中调用 interrupt 方法，就能把 sleep 提前唤醒
sleep被提前唤醒，然后触发异常（此时触发异常后继续执行线程）后，sleep就会把 isInterrupted() 标志位给重置为false

解决方法：在异常后添加break

    public static void main(String[] args) throws InterruptedException {
        Thread t=new Thread(()->{
            //因为这个currentThread 方法是在后续的 t start 之后才执行的
            //Thread方法内还不知道 t 是什么
            //所以不能用 !t.isInterrupted() 作为while循环的条件
            while (!Thread.currentThread().isInterrupted()){
                System.out.println("Thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    break;
                }
            }
        });
        t.start();
        Thread.sleep(2000);
        //在 main 方法中终止t,调用下面方法把线程t终止
        t.interrupt();
        System.out.println("线程终止");
    }

如果想不显示异常就把 e.printStackTrace(); 注释掉

上述两种方式，都是 t 线程自己决定自己是否要终止
约等于main 只是给了 t 一个“提醒” ，并不强制执行

等待一个线程——join()

线程有一个特点，随机调度（或抢占式执行）：当启动两个线程后，线程执行顺序不确定

线程等待，就能约定两个线程的先后执行顺序
让后结束的线程阻塞，等待先结束的线程执行完

public static void main(String[] args) {
        Thread thread=new Thread(()->{
            for (int i=0;i<4;i++){
                System.out.println("Thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        thread.start();
        try {
            System.out.println("等待之前");
            thread.join();
            //Java多线程中，只要这个方法会产生阻塞，
            // 就可能被 interrupt 提前唤醒，就要抛出异常
            System.out.println("等待之后");
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }

执行结果：

此时哪个线程中调用的 join ，该线程就是等的一方（上面就是main等待 thread 结束）

join的等待是 死等，如果join的线程不结束，等待的线程也不会结束

join 虽然可能会触发阻塞，但有时候也不会触发，比如main 等待 t ，如果在 main 的 join 之前，t 就已经结束了，此时 join 就不会阻塞

public static void main(String[] args) throws InterruptedException {
        Thread t=new Thread(()->{
            for (int i=0;i<2;i++){
                System.out.println("Thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        t.start();
        Thread.sleep(3000);
        t.join();//此时已经执行完，不会阻塞了
    }

join设置等待时间

join默认情况下是死等，但是join还有一个重载版本，可以指定等待的最大时间（超时时间）
超过等待时间，就继续执行该线程（不等了）

public void join(long mills)   等待线程结束，最多等待mills毫秒

获取当前线程引用—currentThread()

哪个线程调用 currentThread，就能获取到哪个线程对象的引用

休眠当前线程—sleep()

Thread.sleep 本质就是让线程的状态变成“阻塞”状态
此线程就不参与 CPU 调度了
直到时间到，这个线程的状态再恢复成就绪（不是立即执行，具体执行时间看CPU调度），才能参与CPU调度