【多线程】Thread类及其基本用法

【多线程】Thread类及其基本用法
🥰🥰🥰来都来了，不妨点个关注叭！
👉博客主页：欢迎各位大佬!👈
文章目录
1. Java中多线程编程

 1.1 操作系统线程与Java线程

【操作系统线程】线程是操作系统中的概念，操作系统内核实现线程这样的机制，并对用户层提供一些 API 供用户使用(例如 Linux的pthread库)
【Java线程】Java 标准库中提供了一个类Thread能够表示一个线程，可以认为是对操作系统提供的 API 进行了进一步的抽象和封装，即关于线程的操作是依赖操作系统提供的API

1.2 简单使用多线程

 1.2.1 初步创建新线程代码
```
class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("hello world~");
    }
}
 
public class ThreadDemo {
    public static void main(String[] args) {
        MyThread t = new MyThread();
        t.start();
    }
}
```
打印结果如下~

简单了解这个例子的执行过程，在上述代码中涉及到两个线程分别是：
1）main方法所对应的线程，也可以成为主线程(一个进程里至少得有一个线程)
2）通过t.start()创建的新线程

即主线程中调用t.start()创建一个新的线程，这个新线程调用t.run()，当run()执行结束后这个新线程也会随之销毁，同时main线程也执行结束了(因为t.start()是main线程中最后一个语句)

1.2.2 理解每个线程是一个独立的执行流
```
class MyThread extends Thread {
    @Override
    public void run() {
        while(true) {
            System.out.println("hello t!");
        }
    }
}
public class ThreadDemo1 {
    public static void main(String[] args) {
        Thread t = new MyThread();
        t.start();
        while(true) {
            System.out.println("hello main!");
        }
    }
}
```
打印的结果如下：两个语句交替打印！main线程和新线程是同时在进行的，打印几个hello t!再打印几个hello main!..，尽管两个线程同时进行(通过快速调度，能够交替运行)，两个线程在同一控制台打印，同一控制条必须顺序输出，所以打印会有先后，(如果是单线程，只会打印其中一个，而看不到另一个)

【注意】
交替打印一直执行，因为代码没有创建其它线程，两个死循环在同一线程，快速调度执行，所以会一直循环下去~
接下来，我们进一步了解Thread类~一起来看看吧!

2. 初始Thread类

 2.1 Thread类的常见构造方法

(1）Thread()
创建线程对象
```
Thread t1 = new Thread();
```
(2) Thread(Runnable target)
使用Runnable对象创建线程对象
```
Thread t2 = new Thread(new MyRunnable());
```
(3) Thread(String name)
创建线程对象，并命名
```
Thread t3 = new Thread("我的线程");
```
(4) Thread(Runnable target, String name)
使用Runnable对象创建线程对象，并命名
```
Thread t4 = new Thread(new MyRunnable(),"我的线程");
```
可以通过jconsole工具，查看出java进程里面的线程详情线程名字在这里显示
(5)Thread(ThreadGroup group, Runnable target）
线程可以被用来分组管理，分好的组即为线程组(仅作了解)

2.2 Thread类的常见属性方法

（1）ID --> getID()
ID 是线程的唯一标识，每个线程的ID都是独一无二的
```
public class ThreadDemo5 {
    public static void main(String[] args) {
        Thread t = new Thread( () -> {
            System.out.println("hello t");
            });
        t.start();
        //获取ID属性
        System.out.println(t.getId());
        
        System.out.println("hello main!");

    }
}
```
打印结果如下：

（2）名称 --> getName()
名称是各种调试工具用到的
```
public class ThreadDemo5 {
    public static void main(String[] args) {
        Thread t = new Thread( () -> {
            System.out.println("hello t");
            });
        t.start();
        //获取线程的名字
        System.out.println(t.getName());

        System.out.println("hello main!");

    }
}
```
打印结果如下：

（3）状态 --> getState()
每个线程都有自己的状态，优先级，上下文，记账信息等(在进程与线程这期内容讲到进程的这些属性，都是线程的，只不过之前谈到的进程是属于只有一个线程的进程)，状态表示线程当前所处的一个情况，下期内容会进一步说明~敬请期待！
```
public class ThreadDemo5 {
    public static void main(String[] args) {
        Thread t = new Thread( () -> {
            System.out.println("hello t");
            });
        t.start();
        //获取线程的状态
        System.out.println(t.getState());

        System.out.println("hello main!");

    }
}
```
打印结果如下：

（4）优先级 --> getPriority()
优先级对于系统来说只是给出"建议"，理论上优先级越高，更容易被调度到~
```
public class ThreadDemo5 {
    public static void main(String[] args) {
        Thread t = new Thread( () -> {
            System.out.println("hello t");
            });
        t.start();
        //获取ID属性
        System.out.println(t.getPriority());

        System.out.println("hello main!");

    }
}
```
打印结果如下：

（5）是否为后台线程 --> isDaemon()
如果是true表示为后台线程，false表示是前台线程
【后台线程】后台线程不阻止java进程结束，哪怕后台线程还没执行完，java进程该结束就结束
【前台线程】创建的线程默认是前台线程，可以通过setDaemon()设置成后台线程，JVM会在一个进程的所有非后台线程结束后，才会结束运行
```
public class ThreadDemo5 {
    public static void main(String[] args) {
        Thread t = new Thread( () -> {
            System.out.println("hello t");
            });
        t.start();
        //判断线程t是否为后台线程
        System.out.println(t.isDaemon());

        System.out.println("hello main!");

    }
}
```
打印结果如下：

（6）是否存活 --> isAlive()
判断当前的线程是否处于活动状态，描述的是操作系统里的那个线程是否存活，线程处于正在运行或准备开始运行的状态，就认为线程是"存活"的状态
1）该线程还没调用start方法，并未创建，此时调用该线程isAlive是false
2）线程的入口方法执行完毕，此时系统中对应的线程就没了，此时调用该线程isAlive就是false
下面通过一个例子深入理解isAlive()方法判断线程是否存活的标准
```
public class MyThread extends Thread {

    @Override
    public void run() {
        System.out.println("run=" + this.isAlive());
    }
}
```
```
public class ThreadDemo1{
    public static void main(String[] args) throws InterruptedException {
        Thread t = new MyThread();
        System.out.println("开始=" + t.isAlive());
        t.start();
        System.out.println("结束="+t.isAlive());
    }
}
```
打印结果如下：

【注意】
此处结束返回值不确定！！！
```
System.out.println("结束="+t.isAlive()); //该值是不确定的！！！
```
在上述代码结束输出true是因为t线程还未执行完毕，即输出true，如果将代码为如下形式：
```
public class ThreadDemo1{
    public static void main(String[] args) throws InterruptedException {
        Thread t = new MyThread();
        System.out.println("开始=" + t.isAlive());
        t.start();
        Thread.sleep(1000); //延迟1s
        System.out.println("结束="+t.isAlive());
    }
}
```
此时结束的返回值为false，因为t对象已经在1秒内执行完毕
（7）是否被中断 --> isInterrupted()
判断该线程是否被中断，被中断返回true，未被中断返回false(在本期内容结尾处，介绍interrupted方法，此处不作过多解释)
```
public class ThreadDemo5 {
    public static void main(String[] args) {
        Thread t = new Thread( () -> {
            System.out.println("hello t");
            });
        
        //线程是否中断
        t.start();

        System.out.println(t.isInterrupted());

        System.out.println("hello main!");

    }
}
```
打印结果如下：

3. Thread类的基本用法

 3.1 创建线程

创建线程的五种方法如下：

3.1.1 使用继承Thread，重写run的方式
```
class MyThread extends Thread {
    @Override
    public void run() {
        while(true) {
            System.out.println("hello t!");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class ThreadDemo1 {
    public static void main(String[] args) {
        Thread t = new MyThread();
        t.start();
        while(true) {
            System.out.println("hello main!");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}
```
3.1.2 使用实现Runnable，重写run的方式
```
class MyRunnable implements Runnable {
    @Override
    public void run() {
        while(true){
            System.out.println("hello t!");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class ThreadDemo2 {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread t = new Thread(myRunnable);
        t.start();
        while(true){
            System.out.println("hello main!");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
```
3.1.3 继承Thread，使用匿名内部类的方式
```
public class ThreadDemo3 {
    public static void main(String[] args) {
        Thread t = new Thread() {
            @Override
            public void run() {
                while(true){
                    System.out.println("hello t!");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        t.start();

        while(true){
            System.out.println("hello main!");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
```
3.1.4 实现Runnable类，使用匿名内部类
```
public class ThreadDemo4 {
    public static void main(String[] args) {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                while(true) {
                    System.out.println("hello t!");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        t.start();

        while(true) {
            System.out.println("hello main!");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
```
3.1.5 lambda表达式(最推荐使用，最简单最直观写法）
```
public class ThreadDemo5 {
    public static void main(String[] args) {
        Thread t = new Thread( () -> {
            while(true) {
                System.out.println("hello t!");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();
        while(true) {
            System.out.println("hello main!");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}
```
【解释说明】
（1）第一种写法使用Thread的run方法描述线程入口
（2）第二种写法使用Runnable interface来描述线程入口，使用Runnable 描述一个具体的任务
（3）第一种写法和第二种写法没有本质区别
（4）匿名内部类，匿名则是没有名字，内部类是定义在类里面的类，放到哪里就是针对哪个类创建的匿名内部类

 3.2 线程启动 —— start()

调用start()方法，才是启动线程了，线程才真正独立去执行了
【run方法】
run()叫做入口方法，是特殊的方法，重写了父类的方法，这个run方法就会被java自动执行到，即能被自动调用到，而随便写一个方法只是一个普通方法，没有特殊含义，需要手动去调用
【start方法】
start()调用操作系统的API，创建新的线程，新的线程调用run方法，即通过调用Thread类的start方法来启动一个线程
【区别】
（1）当一个程序调用start方法，将会创建一个新的线程去自动执行run方法中的代码，但如果未使用start方法而是直接调用run方法则是直接在当前线程中执行run方法代码而不会创建新线程
（2）当一个线程启动后，不能再调用start方法，否则会报异常IllegalThreadStateException异常
【总结】
run()是一个入口方法，start()会去创建一个新线程去自动行run()的代码，只有通过调用线程类的start方法才能真正达到多线程的目的

3.3 线程休眠 —— sleep()

public static void sleep(long millis) throws InterruptedException

【含义】sleep方法是Thread的静态方法，参数单位是ms(回顾一下静态方法，即类方法，直接可以通过类调用，无需创建对象)，因为线程的调度是不可控的，这个方法只能保证实际休眠时间是大于等于参数设置的休眠时间的
【作用】使当前线程休眠，进入阻塞状态，即暂停执行，如果线程在睡眠状态被中断，将会抛出InterruptedException中断异常，中断/打断即sleep睡眠过程中，还没到点就被提前唤醒了
【例子】以上面例子，加上sleep方法，如下：
```
class MyThread extends Thread {
    @Override
    public void run() {
        while(true) {
            System.out.println("hello t!");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class ThreadDemo1 {
    public static void main(String[] args) {
        Thread t = new MyThread();
        t.start();
        while(true) {
            System.out.println("hello main!");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}
```
打印结果如下：

通过结果可以看到，交替打印不是像上一个例子那么快，因为加了sleep将会暂停执行1000ms，同时可以看到，此处的交替不是严格的交替，每1000毫秒(即1秒)过后是先打印main还是先打印t是不确定的，原因是多线程在CPU上调度执行的顺序是不确定的，即是随机的，尽管线程有优先级，但对于系统只是“建议”，并不一定采取
【注意】在哪个线程里面调用sleep()方法就休眠哪个线程

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

public static Thread currentThread();
```
public class ThreadDemo5 {
    public static void main(String[] args) {
        Thread t = Thread.currentThread()
        ;
        System.out.println(t.getName());
    }
}
```
打印结果如下：即获取了当前线程的实例，打印该线程的名字，由于并未新创建线程，当前线程为main线程，即获取到main线程实例

 3.4 线程中断 —— interrupt()

当小丁同学去上学进入学习状态，他就会按照学校规定，按时上课，放学了才能回家，但在生活中，可能会出现，家里有一个急事的情况，必须让小丁同学回家，我可以直接给老师打电话，或者直接去学校找小丁，这就涉及该如何通知小丁回家停止当前学习的问题~接下来会介绍两种常见的方式
中断这里就是字面意思，让一个线程停止下来，线程终止，本质上来说，让一个线程终止的办法就一种，即让该线程的入口run方法执行完毕！！(让入口run方法执行完毕可以有，直接return，抛出异常等等)
目前常见的有以下两种方式：
```
1.给线程设定一个结束标志位，通过共享的标记来进行沟通
2.调用interrupt()方法来通知
```
3.4.1 给线程设置一个标志位

(1) 设置一个标志位isQuit

基于上述思路，可以手动给线程设置一个标志位isQuit
首先创建线程t，该线程的代码是死循环，导致t的入口方法永远无法结束，线程也不会结束，一直在执行如下：
```
public class ThreadDemo6 {
    public static void main(String[] args) {
        Thread t = new Thread(()-> {
            while(true) {
                System.out.println("hello t~");
            }

    });
        t.start();
	}
}
```
但是！可以通过控制循环条件，设置变量isQuit像手动开关一样控制线程的结束，当!isQuit为true时执行循环内的逻辑，否则跳出循环，执行完毕，结束线程
```
public class ThreadDemo6 {
    public static boolean isQuit = false;
    public static void main(String[] args) {
        Thread t = new Thread(()-> {
            while(!isQuit) {
                System.out.println("hello t~");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("t线程终止！");
        });
        t.start();

        //在主线程中修改isQuit
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        isQuit = true;
    }
}
```
打印结果如下：：
该代码执行过程为打印3次"hello t~“，!isQuit 被修改为false，t 线程中的循环终止，打印” t线程终止!"这个语句后， t 线程结束，此时main线程代码也执行完毕，main线程结束，因此整个进程也随之结束

(2) 注意isQuit的位置

为什么这里将isQuit设置为成员变量，编写在main方法外，而不写在main方法里，作为局部变量呢?
下面进行演示，将isQuit设置为局部变量，发现代码报错
-------------------------------------------------------- 在此特别说明 --------------------------------------------------------

(3) isQuit不能为局部变量的原因

错误理解：
有些同学可能认为，出现该错误是因为isQuit这个使用变量超出它的作用域，但事实并非如此！线程t是可以正常拿到main线程中的变量，同一进程的线程和线程之间共用内存地址空间，比如同一进程，创建线程1、2、3，线程1创建出来的变量在线程2、3中同样也能访问到，内存地址共用，即变量也共用
正确原因：
变量捕获，lambda表达式是可以访问它外面的局部变量，但这里涉及到变量捕获这一语法规则，Java语法要求变量捕获，捕获到的变量必须是final或实际final，final指的是被final修饰的变量，实际final指的是，虽然一个变量没有用final关键字修饰，但是代码中并没有尝试过修改它，即该变量没有做出过修改，在上述代码中，在最后一行作出修改isQuit为true的操作，违背变量捕获的语法要求，因此变量捕获失败，程序编译报错
解决方式：
即按照最开始的代码，将isQuit设置为成员变量，在main中访问成员变量不受变量捕获规则的限制，即不会存在上述问题

 3.4.2 调用interrupt()方法来通知

要知道我们自己手动创建变量控制循环是比较麻烦的~Thread类内置了一个标志位isInterrupted()，更方便实现上述效果，isInterrupted()可以理解是t对象自带的一个结束标志位，通过 t.interrupt() 方法将t内部的标志位给设置为 true，代码如下：
```
public class ThreadDemo7 {
    public static void main(String[] args) {
        Thread t = new Thread(()->{
           //currentThread 是获取到当前线程实例
           //此处currentThread得到对象就是t
            //isInterrupted 就是t对象自带的一个标志位
            while(!Thread.currentThread().isInterrupted()) {
                System.out.println("hello t!");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    break;
                }
            }
        });

        t.start();
        
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //把t内部标志位给设置为true
        t.interrupt();
    }
}
```
打印结果如下：
但事实上，运行结果并不是我们想要的线程中断效果，通过上述打印结果可以看到，3秒时间到，调用 t.interrupt() 方法的时候，线程t并没有真正终止，而是打印异常信息之后又继续执行！该异常信息由while循环中catch捕获并打印
为什么会出现这样的情况呢？？这就需要我们了解interrupt方法的两个作用！它会将sleep提前唤醒！这正是上述代码异常的原因

(1) interrupt方法的作用

(1) 设置标志位为true
(2) 如果该线程正在阻塞中，比如正在执行的sleep、wait、join等，此时就会把该阻塞状态唤醒，通过抛出异常的方式让其立即结束

【解释说明】
在上述情况中，如果sleep被提前唤醒的时候，sleep会自动把isInterrupted标志位给清空（true变为false），这就导致下次再判断循环条件，循环条件还成立，循环仍然可以继续执行，而interrupt()执行时，如果t线程正在sleep，interrupt()在将标志位设置为true后，会直接将sleep强行唤醒。sleep的时间已经占据了整个循环体的绝大部分！！！非常非常多部分，因此当interrupt()执行时，几乎一定会遇到正在sleep的情况，sleep第一次执行，清空标志位，并抛出异常，这次设置的中断就翻篇，sleep第二次执行，没有这个中断的标志位了，而如果设置interrupt的时候恰好sleep唤醒，这时候是非常巧的！！概率极其低，此时执行到下一轮的循环条件就直接结束了

打个比方，这就好比你今天打算7点起来，但是你的妈妈五点来你的房间喊醒你，还把你房间的灯打开了，你一看手机发现才凌晨五点，又把灯关了，继续睡觉了~

主线程只调用一次interrupt()，即主线程并非是循环反复设置t内部的标志位，而是只执行一次，因此抛出1次异常后，就不会再次抛出异常
如果需要结束循环，需要怎么做呢？
【解决方案】在catch{}中，加一个break！

(2) sleep为什么要清空标志位

【目的】让线程自身能够对于线程何时结束有一个更明确的控制
当前interrupt方法的效果不是让线程立即结束，而是告诉它，你该结束了，它是否真的要结束，立即结束还是过一会结束，都是由代码灵活控制的！
interrupt方法只是通知，而不是"命令"！！！

比如我在学习，我的妈妈让我去超市买点菜
（1）直接无视她的要求，继续学习(不去)
（2）立即放下学习，赶紧起身去买菜(立马去)
（3）我说，等我学完这一节课我再去(等会去)

为什么Java这里不强制设置为命令结束操作，即一调用interrupt不是通知，而是命令，就立即结束了
【原因】
这种设定非常不友好，线程t何时结束，一定是线程t自己最清楚，交给t自身来决定比较好！

3.5 线程等待 —— join()

线程之间是并发执行的，即操作系统对于线程的调度是无序的，无法判定两个线程谁先执行结束，谁后执行结束！
```
public class ThreadDemo1{
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()-> {
            System.out.println("hello t");
        });
        t.start();
        System.out.println("hello main");
    }
}
```
本次运行该代码打印结果如下：

先输出hello main还是hello t？？？这是无法确定的！这个代码实际执行的时候，大部分情况下都是先出hello main，比如上述打印结果，因为线程创建也有开销，但是不排除特定情况下，主线程hello main没有立即执行到的~
要知道程序猿不喜欢不确定的~有时候就需要明确规定线程的结束顺序，可以使用线程等待来实现！
等待线程就是控制两个线程结束的顺序，接下来join方法闪亮登场！

3.5.1 join无参数
```
public class ThreadDemo1{
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()-> {
            System.out.println("hello t");
        });
        t.start();
        t.join();
        System.out.println("hello main");
    }
}
```
打印结果如下：

在t.join执行的时候，如果t线程还没有结束，main线程就会阻塞等待！

如果是t1线程中，调用t2.join就是让t1线程等待t2线程结束，t1线程阻塞，其它线程正常调度！
在哪个线程调用该线程的join方法，就是让哪个线程等待该线程结束
【t.join作用】
（1）main线程调用t.join的时候，如果t还在运行此时main线程阻塞，直到t线程结束，即t的run方法执行完毕，main才从阻塞中解除，才继续执行
（2）main线程调用t.join的时候，如果t已经结束了，此时join不会阻塞，就会立即执行下去
总之，t.join都能保证t线程是先结束的那个，明确控制线程结束的执行顺序！

3.5.2 join有参数

但是如果t线程里面有死循环，那main线程就要一直等待下去吗？？？
这里就介绍join的另一个版本，带参数的join，可以填一个参数作为"超时时间"，即等待的最大时间~
join的无参版本，效果是"死等"，必须等到该线程结束
join的有参版本，效果是指定最大时间，如果等待时间到了上限，还没等到，就不等了（在生活中也是如此~所以这是很常见的设定）
```
public class ThreadDemo1{
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()-> {
            while (true) {
                System.out.println("hello t");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();
        t.join(3000);
        System.out.println("hello main");
    }
}
```
打印结果如下：

因为t线程中代码是死循环，将会一直打印hello t，使用带参数的join方法，则超过3秒后（这里举例子，实际最大等待时间可能更长），main线程执行，打印hello main，只打印一次，接着将一直循环打印hello t~这就是带参数的join方法！
本期内容就到这里结束啦~全是干货，疯狂进行知识输入！！！嘿嘿，一起加油努力吧
💛💛💛本期内容回顾💛💛💛

✨✨✨本期内容就到这里结束啦！继续努力吧~
相关阅读:
小程序 input type=‘number‘ 不能输入小数点？？
皮皮仔！在 vscode 里操作数据库~
Roadmap - Backend
消息队列实现进程间通信
 优优嗨聚集团：美团外卖，让美好儿童餐计划触手可及
 人工智能如何管理实时视频流
 优秀商业程序员的基础
 33. 干货系列从零用Rust编写正反向代理，关于HTTP客户端代理的源码实现
 通过动态IP解决网络数据采集问题
 SAP ERP系统里的那些核心主数据
原文地址：https://blog.csdn.net/m0_61814277/article/details/137997086

文章目录

1. Java中多线程编程

1.1 操作系统线程与Java线程

1.2 简单使用多线程

1.2.1 初步创建新线程代码

1.2.2 理解每个线程是一个独立的执行流

2. 初始Thread类

2.1 Thread类的常见构造方法

2.2 Thread类的常见属性方法

3. Thread类的基本用法

3.1 创建线程

3.1.1 使用继承Thread，重写run的方式

3.1.2 使用实现Runnable，重写run的方式

3.1.3 继承Thread，使用匿名内部类的方式

3.1.4 实现Runnable类，使用匿名内部类

3.1.5 lambda表达式(最推荐使用，最简单最直观写法）

3.2 线程启动 —— start()

3.3 线程休眠 —— sleep()

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

3.4 线程中断 —— interrupt()

3.4.1 给线程设置一个标志位

(1) 设置一个标志位isQuit

(2) 注意isQuit的位置

(3) isQuit不能为局部变量的原因

3.4.2 调用interrupt()方法来通知

(1) interrupt方法的作用

(2) sleep为什么要清空标志位

3.5 线程等待 —— join()

3.5.1 join无参数

3.5.2 join有参数