Java 线程的生命周期线程中断线程插队守护线程

VincentHu_

已于 2024-02-19 11:48:32 修改

阅读量927

点赞数 32

分类专栏： Java 文章标签： java 开发语言

于 2024-02-19 10:47:54 首次发布

本文链接：https://blog.csdn.net/weixin_44895385/article/details/136164597

版权

Java 专栏收录该内容

79 篇文章 2 订阅

订阅专栏

线程中断

场景：线程休眠时使用

代码演示：

public class ThreadTest {
    public static void main(String[] args) throws InterruptedException {

        T t = new T();
        Thread thread = new Thread(t);
        thread.setName("吃东西线程");

        // 开启线程
        thread.start();

        for (int i = 0; i < 3; i++) {
            System.out.println("主线程的逻辑代码....");
            Thread.sleep(1000);
        }

        // 开启线程后，执行五次吃东西会进入20秒的休眠，在此期间，调用interrupt方法中断线程
        // 然后该线程就会抛出InterruptedException，而我们使用catch捕获了该异常
        // 从而执行catch中的代码
        System.out.println("中断" + thread.getName());
        thread.interrupt();
    }
}

class T implements Runnable {
    @Override
    public void run() {
        int a = 0;
        while (a < 50) {
            System.out.println("吃东西..." + a++);
            if (a % 5 == 0) {
                try {
                    // 当吃东西执行五次后，休眠20秒
                    System.out.println("开始休眠，休眠中...");
                    Thread.sleep(20000);
                    System.out.println("休眠结束...");
                } catch (InterruptedException e) {
                    // 当该线程执行到interrupt方法时，会抛出一个InterruptedException异常
                    // 可以在捕获到该异常时，加入业务代码，处理逻辑
                    System.out.println(Thread.currentThread().getName() + "在休眠的时候被中断了....");
                }
            }
        }

    }
}

执行上面程序，得到一下结果。

可以看到，吃东西线程在第一次休眠的时候，被唤醒没有执行“休眠结束”语句，因为是在中断时抛出了异常，直接执行catch块中的代码，而此时的中断，直接中断了20秒的睡眠。
可以理解为，让该线程中断一下，然后继续执行该线程的代码。
因为睡眠20秒的那行代码已经执行过了，再加上中断sleep方法会抛出异常，所以直接进入catch块中的代码，如果没有sleep20秒而中断的话，则不会抛出异常，而是中断后，继续执行下面代码。

中断方法还可以配合重新设置优先级来使用，比如该线程之前的优先级是10，在主线程重新设置该线程的优先级后，中断一下。

在这里插入图片描述

线程插队

场景：
当主线程的i == 3的时候，优先执行子线程，子线程执行完毕后，再执行主线程。

public class ThreadTest {
    public static void main(String[] args) throws InterruptedException {

        T t = new T();
        Thread thread = new Thread(t);

        // 开启线程
        thread.start();

        for (int i = 0; i < 10; i++) {
            System.out.println("主线程的吃东西...." + i);
            Thread.sleep(1000);
            if (i == 3) {
                // 让子线程先执行，执行完毕后再执行当前线程
                thread.join();
            }
        }
    }
}

class T implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("子线程的吃东西...." + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

可以看到，结果符合预期
在这里插入图片描述

用户线程和守护线程

用户线程： 也叫工作线程，当线程的任务执行完或通知方式结束

守护线程： 一般为工作线程服务的，当所有的用户线程结束，守护线程自动结束。

常见的守护线程：垃圾回收机制

在java中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。因为每当使用java命令执行一个类的时候，实际上都会启动一个JVM，每一个JVM其实在就是在操作系统中启动了一个进程。

场景：
设置守护线程。

public class ThreadTest {
    public static void main(String[] args) throws InterruptedException {

        T t = new T();
        Thread thread = new Thread(t);

        // 设置为守护线程，这样，主线程结束后，守护线程也就结束了
        thread.setDaemon(true);

        // 开启线程，先设置，后开启
        thread.start();

        for (int i = 0; i < 5; i++) {
            System.out.println("主线程的吃东西...." + i);
            Thread.sleep(1000);
        }
    }
}

class T implements Runnable {
    @Override
    public void run() {
        // 死循环，如果不设置为守护线程，该循环不会停下
        for (; ; ) {
            System.out.println("子线程的吃东西....");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

可以看到，主线程结束后，子线程哪怕是死循环，也会结束
在这里插入图片描述

线程的生命周期(状态)

当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。

新建(New)
可运行(Runnable)
正在运行(Running)
阻塞(Blocaked)
终止(Dead)

在这里插入图片描述

在API中 java.lang.Thread.State 这个枚举中给出了六种线程状态：

线程状态	导致状态发生条件
NEW（新建）	线程刚被创建，但是并未启动。还没调用start方法。
Runnable（可运行）	线程可以在java虚拟机中运行的状态，可能正在运行自己代码，也可能没有，这取决于操作系统处理器。而在该状态，可以在内核中分为`Ready`(就绪)和`Running`(运行)状态
Blocked（锁阻塞）	当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状态；当该线程持有锁时，该线程将变成Runnable状态。
Waiting（无限等待）	一个线程在等待另一个线程执行一个（唤醒）动作时，该线程进入Waiting状态。进入这个状态后是不能自动唤醒的，必须等待另一个线程调用notify或者notifyAll方法才能够唤醒。
TimedWaiting（计时等待）	同waiting状态，有几个方法有超时参数，调用他们将进入Timed Waiting状态。这一状态将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有Thread.sleep 、Object.wait。
Teminated（被终止）	因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡。

阻塞(Blocaked)

计时等待 TimedWaiting

Timed Waiting在API中的描述为：一个正在限时等待另一个线程执行一个（唤醒）动作的线程处于这一状态。

static void sleep(long millis)：使当前正在执行的线程以指定的毫秒值休眠（暂时停止执行）

在run方法中添加了sleep语句，这样就强制当前正在执行的线程休眠（暂停执行），以“减慢线程”。当调用sleep方法之后，当前执行的线程就进入到“休眠状态”，就是Timed Waiting（计时等待）。

在这里插入图片描述

① 进入 TIMED_WAITING 状态的一种常见情形是调用的 sleep 方法，单独的线程也可以调用，不一定非要有协作关系。
② 为了让其他线程有机会执行，可以将 Thread.sleep() 的调用放线程 run() 之内。这样才能保证该线程执行过程中会睡眠。
③ sleep与锁无关，线程睡眠到期自动苏醒，并返回到Runnable（可运行）状态。
④ sleep()中指定的时间是线程不会运行的最短时间。sleep()方法不能保证该线程睡眠到期后就开始立刻执行。

锁阻塞 BLOCKED

Blocked状态在API中的介绍为：一个正在阻塞等待一个监视器锁（锁对象）的线程处于这一状态。

比如，线程A与线程B代码中使用同一锁，如果线程A获取到锁，线程A进入到Runnable状态，那么线程B就进入到Blocked锁阻塞状态。这是由Runnable状态进入Blocked状态。

在这里插入图片描述

无限等待 Waiting

Wating状态在API中介绍为：一个正在无限期等待另一个线程执行一个特别的（唤醒）动作的线程处于这一状态。

一个调用了某个对象的Object.wait()方法的线程会等待另一个线程调用此对象的Object.notify()方法或Object.notifyAll()方法。

waiting状态不是一个线程的操作，它体现的是多个线程间的通信，可以理解为多个线程之间的协作关系，多个线程会争取锁，同时相互之间又存在协作关系。

在这里插入图片描述

当多个线程协作时，比如A，B线程，如果A线程在Runnable（可运行） 状态中调用了wait()方法那么A线程就进入了 Waiting（无限等待）状态，同时失去了同步锁。假如这个时候B线程获取到了同步锁，在运行状态中调用了 notify() 方法，那么就会将无限等待的A线程唤醒。注意是唤醒，如果获取到锁对象，那么A线程唤醒后就进入Runnable（可运行） 状态；如果没有获取锁对象，那么就进入到 Blocked（锁阻塞状态）。

线程的等待唤醒机制

在这里插入图片描述

在翻阅API的时候发现 Timed Waiting（计时等待） 与 Waiting（无限等待） 状态联系是很紧密的。

比如，Waiting（无限等待）状态中wait方法是空参的，而timed waiting（计时等待）中wait方法是带参的。这种带参的方法，其实是一种倒计时操作，相当于生活中的小闹钟，设定好时间，到时通知，可是如果提前得到（唤醒）通知，那么设定好时间在通知也就显得多此一举了。如果没有得到（唤醒）通知，线程就处于Timed Waiting状态，直到倒计时完毕自动醒来；如果在倒计时期间得到（唤醒）通知，线程从Timed Waiting状态立刻唤醒。

线程优先级

Java为线程类提供了10个优先级，优先级可以用整数1-10表示，超过范围会抛出异常，主线程默认优先级为5，也可以使用优先级常量设置优先级

优先级常量： java.lang.thread

MAX_PRIORITY：线程的最高优先级10
MIN_PRIORITY：线程的最低优先级1
NORM_PRIORITY：线程的默认优先级5

优先级相关的方法： java.lang.thread

int getPriority()：获取线程优先级
void setPriority(int newPriority)：设置线程优先级

public class MyThreadPriority {

    public static void main(String[] args) {
        int mainPriority = Thread.currentThread().getPriority();
        System.out.println("主线程优先级为" + mainPriority);

        MyThread03 mt1 = new MyThread03("线程1");
        // mt1.setPriority(10);
        mt1.setPriority(Thread.MAX_PRIORITY);
        mt1.start();
        System.out.println("线程1的优先级为"+ mt1.getPriority());
    }
}

class MyThread03 extends Thread {
    private String name;

    public MyThread03(String name) {
        this.name = name;
    }

    public void run() {
        for (int i = 0; i < 30; i++) {
            System.out.println("线程" + name + "正在运行第" + i + "次");
        }
    }
}