【多线程】Thread的常见属性 | 终止线程 | 等待线程 | 休眠线程

文章目录

- 一、Thread的方法
- - - Thread的常见属性
    - - 后台线程（守护线程）
      - 设置后台线程
        是否存活
    - 启动线程
    - 终止\打断一个线程
    - - 1.创建标志位
        2.调用 interrupt() 方法
    - 等待一个线程 join()
    - - t.join（）的工作过程：
    - 休眠一个进程sleep
- 二、线程的状态
- 1、线程安全
- - 1.什么是线程安全
  - 2.产生线程安全问题的原因：

一、Thread的方法

创建线程的时候，可以指定name

    public static void main(String[] args) {Thread t = new Thread(()->{while (true){System.out.println("这是我的新线程");try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}}},"这是新线程");t.start();}

在这里插入图片描述

name不影响线程的执行，只是取了一个名字，方便后续区分
线程的入口方法执行结束，就会销毁。在start执行完后，main方法执行结束。主线程就没有了。

Thread的常见属性

	ID getid() //线程的身份标识名称 getName()状态 getState()优先级 getPriority()  //微观调度是否后台线程 isDaemon()是否存活 isAlive()是否被中断 isInterrupted()

标识一个进程中唯一的线程。是Java给这个线程分配的，不是操作系统api提供的线程id、也不是PCB的id

后台线程（守护线程）

一个Java进程中，如果前台线程没有执行结束，那么整个进程不会结束。

后台线程不结束，不影响整个进程的结束。

后台线程不影响进程的结束

默认情况下，一个线程就是前台线程

设置后台线程

    public static void main(String[] args) {Thread t = new Thread(()->{while (true){System.out.println("这是我的新线程");try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}}},"这是新线程");//设置t为后台线程t.setDaemon(true);t.start();}

在start之前，设置t为后台进程。

此时，不会打印任何内容。因为主线程快速执行完后，没有其他前台线程，进程结束。

是否存活

使用isAlive判断内核线程是否销毁。

当回调方法执行完毕，线程就销毁了。

Thread对象的生命周期，要比系统内核中的线程要长一些。会出现，Thread对象还在，但是系统内核中的线程已经被销毁了的情况

    public static void main(String[] args) throws InterruptedException {Thread t = new Thread(() -> {System.out.println("线程开始");try {Thread.sleep(2000);} catch (InterruptedException e) {throw new RuntimeException(e);}System.out.println("线程结束");});t.start();System.out.println(t.isAlive());Thread.sleep(3000);System.out.println(t.isAlive());}true  //线程正在运行
线程开始
线程结束  
false //线程结束了

true和线程开始，这两条日志的打印顺序不一定。因为是并发执行的。

大概率先打印true,因为调用start后，创建新线程也存在一定开销，创建的过程中，主线程就开始打印了。

启动线程

start方法和run方法的区别

1.start方法内部，会调用系统API，在系统内核中创建一个线程。

2.run方法是这个线程的入口方法，描述了这个线程要执行什么内容，会在start创建好线程后自动被调用。

终止\打断一个线程

让一个线程停止运行（销毁）

在Java中，销毁\终止线程的方法，就是想办法让run方法尽快执行结束。

interrupt

1.创建标志位

手动创建一个标志位，作为run执行结束的条件

    private static boolean isQuit = false;public static void main(String[] args) throws InterruptedException {Thread t = new Thread(()->{while (!isQuit){//内部类访问外部类属性System.out.println("线程工作中");try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}}System.out.println("线程工作完毕");});t.start();//五秒后，设为trueThread.sleep(5000);isQuit = true;System.out.println("设置isQuit为true");}线程工作中
线程工作中
线程工作中
线程工作中
线程工作中
设置isQuit为true
线程工作完毕

isQuit是一个成员变量，不能作为main方法中的局部变量。因为lambda表达式的变脸捕获。lambda表达式里面的代码可以自动捕获到上层作用域当中的局部变量。且这个变量不能进行修改。

变量捕获就是让lambda表达式把当前作用域的变量，在lambda内部复制了一份。外部是否销毁无所谓。

变量捕获只能捕获final或者实际上是final的变量（没有修改）。

2.调用 interrupt() 方法

            while (Thread.currentThread().isInterrupted()){//获取当前线程的引用，   //判断标志位是否修改}

Thread.currentThread()获取当前线程的实例，得到的就是t

哪个线程调用currentThread这个方法，就会返回哪个线程的对象。

isInterrupted()是Thread内部的标志位

    public static void main(String[] args) throws InterruptedException {Thread t = new Thread(() -> {while (!Thread.currentThread().isInterrupted()){System.out.println("线程正在工作中");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}});t.start();Thread.sleep(5000);System.out.println("让t线程终止");t.interrupt();//把标志位设为true}
//终止后会继续运行

即使线程内部是阻塞状态，interrupt() 方法也可以进行唤醒。

正常情况下，sleep会休眠到时间才会唤醒。interrupt() 方法可以使sleep内部触发一个异常，从而提前唤醒。

interrupt() 方法唤醒线程后，此时sleep方法抛出异常，同时会自动清除刚才设置的标志位

Java期望，当线程收到信号后，能自己决定需不需要处理。

    public static void main(String[] args) throws InterruptedException {Thread t = new Thread(() -> {while (!Thread.currentThread().isInterrupted()){System.out.println("线程正在工作中");try {Thread.sleep(1000);} catch (InterruptedException e) {//1.假装没听到，循环继续执行e.printStackTrace();//2.加上break，让线程立即结束//3.把其他代码放在这里执行完再结束。break;}}});t.start();Thread.sleep(5000);System.out.println("让t线程终止");t.interrupt();//把标志位设为true

提供了更多的可操作空间。这个前提的通过异常唤醒的，如果没有sleep，就直接结束。

等待一个线程 join()

让一个线程等待另一个线程执行结束后再进行执行。

本质是控制进程结束的顺序。

join方法，实现了线程等待的效果。

在主线程中调用t.join().就是主线程等待t线程先结束

    public static void main(String[] args) throws InterruptedException {Thread t = new Thread(()->{for (int i = 0; i < 5; i++) {System.out.println("t线程工作中");try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}}});t.start();System.out.println("join等待开始");t.join();//让主线程等待t线程执行结束//一旦调用join，主线程就会堵塞。一直等到t执行完毕。System.out.println("join等待结束");}
join等待开始
t线程工作中
t线程工作中
t线程工作中
t线程工作中
t线程工作中
join等待结束

t.join（）的工作过程：

1.如果t线程正在运行中，此时调用join的线程就会堵塞，一直堵塞到t线程执行结束为止。

2.t线程已经结束，就直接返回了，不会堵塞。

3.join默认是死等待，一般都要带有一个超时时间

  t.join(3000);

休眠一个进程sleep

        System.out.println("开始："+System.currentTimeMillis());Thread.sleep(1000);System.out.println("结束："+System.currentTimeMillis());开始：1712746732288
结束：1712746733296

sleep休眠的时间并不准确。

系统会按照1000毫秒让线程休眠。时间到了之后，系统会唤醒这个线程，从阻塞状态转化为就绪状态。但是不会立即回到CPU上执行。会存在一个调度开销

二、线程的状态

在Java中，给线程赋予了一些其他状态。
NEW: Thread对象已经存在了，start方法还没有开始调用
TERMINATED: Thread对象还在，但是内核中的线程已经没了
RUNNABLE:就绪状态：（线程已经在CPU上执行了、线程正在排队等待上CPU执行）
TIMED_WAITING:阻塞状态：由于sleep这种固定时间的方式产生的阻塞。
WAINTING:阻塞：由于wait这种不固定时间的方式产生的阻塞。
BLOCKED:阻塞：由于锁竞争导致的阻塞

1、线程安全

1.什么是线程安全

有的代码在单线程环境下，可以正常执行。但是同样的代码，让多个线程去同时执行，就有可能出现BUG。

这类问题就是线程安全问题/线程不安全。

    public static int count = 0;public static void main(String[] args) throws InterruptedException {Thread t1 = new Thread(() -> {//对变量自增50000次for (int i = 0; i < 50000; i++) {count++;}});Thread t2 = new Thread(() -> {for (int i = 0; i < 50000; i++) {count++;}});t1.start();t2.start();t1.join();t2.join();//没有join的话，线程还没自增完，就会打印countSystem.out.println("count: "+count);}count: 56269count: 54242count: 56125