【 Thread类及常见方法】

卷我没对象、

已于 2023-03-23 15:51:43 修改

阅读量410

点赞数 1

分类专栏：多线程文章标签： java

于 2023-03-18 20:00:29 首次发布

本文链接：https://blog.csdn.net/qq_64317046/article/details/129637172

版权

多线程专栏收录该内容

10 篇文章 0 订阅

订阅专栏

文章目录

引言
一、Thread 常见构造方法
二、Thread 常见属性
- 2.1 拓展：线程的状态
三、Thread 中的重要方法

引言

Thread 类是 JVM 用来管理线程的一个类，换句话说，每个线程都有一个唯一的 Thread 对象与之关联。用我们上面的例子来看，每个执行流，也需要有一个对象来描述，类似下图所示，而 Thread 类的对象就是用来描述一个线程执行流的，JVM 会将这些 Thread 对象组织起来，用于线程调度，线程管理。
在这里插入图片描述

一、Thread 常见构造方法

在这里插入图片描述

举例：

Thread t1 = new Thread();
Thread t2 = new Thread(new MyRunnable());
Thread t3 = new Thread("haha");
Thread t4 = new Thread(new MyRunnable(), "heihei");

二、Thread 常见属性

在这里插入图片描述

ID 是线程的唯一标识，不同线程不会重复
名称是各种调试工具用到
状态表示线程当前所处的一个情况，下面我们会进一步说明
优先级高的线程理论上来说更容易被调度到
关于后台线程，需要记住一点：JVM会在一个进程的所有非后台线程结束后，才会结束运行。
是否存活，即简单的理解，为 run 方法是否运行结束了
线程的中断问题，下面我们进一步说明

注意：

在这里插入图片描述

示例：

package ThreadTest;

public class Demo8 {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    System.out.println(Thread.currentThread().getName() + ": 我还活着");
                    Thread.sleep(1 * 1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().getName() + ": 我即将死去");
        });

        //Thread.currentThread()意思是返回当前线程对象，某些情况也可以直接用this
        System.out.println(Thread.currentThread().getName() + ": ID: " + thread.getId());

        System.out.println(Thread.currentThread().getName() + ": 名称: " + thread.getName());

        System.out.println(Thread.currentThread().getName() + ": 状态: " + thread.getState());

        System.out.println(Thread.currentThread().getName() + ": 优先级: " + thread.getPriority());

        System.out.println(Thread.currentThread().getName() + ": 后台线程: " + thread.isDaemon());

        System.out.println(Thread.currentThread().getName() + ": 活着: " + thread.isAlive());

        System.out.println(Thread.currentThread().getName() + ": 被中断: " + thread.isInterrupted());

        thread.start();

        while (thread.isAlive()) {}
        System.out.println(Thread.currentThread().getName() + ": 状态: " + thread.getState());
    }
}

运行结果：

在这里插入图片描述

2.1 拓展：线程的状态

线程的所有状态：

线程的状态是一个枚举类型 Thread.State

public class ThreadState {
    public static void main(String[] args) {
        for (Thread.State state : Thread.State.values()) {
            System.out.println(state);
        }
    }
}

NEW: 安排了工作, 还未开始行动
RUNNABLE: 可工作的. 又可以分成正在工作中和即将开始工作.
BLOCKED: 这几个都表示排队等着其他事情
WAITING: 这几个都表示排队等着其他事情
TIMED_WAITING: 这几个都表示排队等着其他事情
TERMINATED: 工作完成了.

线程状态和状态转移的意义：
在这里插入图片描述

以上的图解太过复杂，可以参考下简图：

在这里插入图片描述

理解状态的意义以及各个状态的具体意思：

在这里插入图片描述

还是我们之前的例子：

刚把李四、王五找来，还是给他们在安排任务，没让他们行动起来，就是 NEW 状态；当李四、王五开始去窗口排队，等待服务，就进入到 RUNNABLE 状态。该状态并不表示已经被银行工作人员开始接待，排在队伍中也是属于该状态，即可被服务的状态，是否开始服务，则看调度器的调度;当李四、王五因为一些事情需要去忙，例如需要填写信息、回家取证件、发呆一会等等时，进入BLOCKED 、 WATING 、 TIMED_WAITING 状态，至于这些状态的细分，我们以后再详解；如果李四、王五已经忙完，为 TERMINATED 状态。所以，之前我们学过的 isAlive() 方法，可以认为是处于不是 NEW 和 TERMINATED 的状态都是活着的

三、Thread 中的重要方法

3.1 启动线程-start()

之前我们已经看到了如何通过覆写 run 方法创建一个线程对象，但线程对象被创建出来并不意味着线程就开始运行了。

覆写 run 方法是提供给线程要做的事情的指令清单
线程对象可以认为是把李四、王五叫过来了
而调用 start() 方法，就是喊一声：”行动起来！“，线程才真正独立去执行了。

在这里插入图片描述

调用 start 方法, 才真的在操作系统的底层创建出一个线程.

思考：

已经强调了调用 start 方法, 才真的在操作系统的底层创建出一个线程，但是为什么使用run方法也能够创建出一个线程呢？
在这里插入图片描述

其实Run方法只是一个普通的方法，当你在main方法中调用run方法时并没有真正创建新的线程，这个循环任然是在main线程中执行的！！！ 由此可见，start方法是一个特殊的方法，调用它才会创建一个线程，而run方法则是一个普通方法，它只是描述了线程任务的内容！

3.2 线程中断-interrupt()

李四一旦进到工作状态，他就会按照行动指南上的步骤去进行工作，不完成是不会结束的。但有时我们需要增加一些机制，例如老板突然来电话了，说转账的对方是个骗子，需要赶紧停止转账，那张三该如何通知李四停止呢？这就涉及到我们的停止线程的方式了。

目前常见的有以下两种方式：

通过共享的标记来进行沟通
调用 interrupt() 方法来通知

示例-1: 使用自定义的变量来作为标志位.
需要给标志位上加 volatile 关键字(这个关键字的功能后面介绍)

private static class MyRunnable implements Runnable {
        public volatile boolean isQuit = false;

        @Override
        public void run() {
            while (!isQuit) {
                System.out.println(Thread.currentThread().getName()
                        + ": 别管我，我忙着转账呢!");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().getName()
                    + ": 啊！险些误了大事");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        MyRunnable target = new MyRunnable();
        Thread thread = new Thread(target, "李四");
        System.out.println(Thread.currentThread().getName()
                + ": 让李四开始转账。");
        thread.start();
        Thread.sleep(10 * 1000);
        System.out.println(Thread.currentThread().getName()
                + ": 老板来电话了，得赶紧通知李四对方是个骗子！");
        target.isQuit = true;
    }

注意： 此时需要这些线程共用同一个虚拟地址空间，才能保证标志位是同一个值

示例-2: 使用 Thread.interrupted() 或者 Thread.currentThread().isInterrupted() 代替自定
义标志位

Thread 内部包含了一个 boolean 类型的变量作为线程是否被中断的标记

在这里插入图片描述

public class ThreadInterrupt {
    private static class MyRunnable implements Runnable {
        @Override
        public void run() {
            // 两种方法均可以
            while (!Thread.interrupted()) {//这个方法判定的标志位是Thread的static成员(一个程序只能有一个标志位)   会清除中断标志
                //无脑使用 while (!Thread.currentThread().isInterrupted()) 判定的标志是Thread的普通成员，每个示例都有自己的标志  不会清除中断标志
                System.out.println(Thread.currentThread().getName() + ": 别管我，我忙着转账呢!");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    System.out.println(Thread.currentThread().getName() + ": 有内鬼，终止交易！");
                    //注意此处的 break！打印出异常日志后，如果不加break还是会继续该循环
                    break;
                }
            }
            System.out.println(Thread.currentThread().getName() + ": 啊！险些误了大事");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        MyRunnable target = new MyRunnable();
        Thread thread = new Thread(target, "李四");
        System.out.println(Thread.currentThread().getName() + ": 让李四开始转账。");
        thread.start();
        Thread.sleep(5 * 1000);
        System.out.println(Thread.currentThread().getName() + ": 老板来电话了，得赶紧通知李四对方是个骗子！");

        //注意：调用此方法会出现两种情况。
        //1、如果thread线程是就绪状态，就设置标志位为true
        //2、如果处在阻塞状态(sleep休眠)就会触发一个interruptException异常，从而导致线程从阻塞状态被唤醒，打印完异常日志后加上break终止循环
        thread.interrupt();
    }
}

调用interrupt方法后，thread 收到通知的方式有两种：

如果线程因为调用 wait/join/sleep 等方法而阻塞挂起，则以 InterruptedException 异常的形式通知，清除中断标志当出现 InterruptedException 的时候, 要不要结束线程取决于 catch 中代码的写法. 可以选择忽略这个异常, 也可以使用 break 跳出循环结束线程
否则，只是内部的一个中断标志被设置，thread 可以通过Thread.interrupted() 判断当前线程的中断标志被设置，清除中断标志。Thread.currentThread().isInterrupted() 判断指定线程的中断标志被设置，不清除中断标志，这种方式通知收到的更及时，即使线程正在 sleep 也可以马上收到。

注意：

标志位是否清除, 就类似于一个开关。Thread.Interrupted() 相当于按下开关, 开关自动弹起来了. 这个称为 “清除标志位”。Thread.currentThread().isInterrupted() 相当于按下开关之后, 开关弹不起来, 这个称为"不清除标志位"。

拓展：

Thread.currentThread().isInterrupted()使我们最推荐的做法，无脑使用！咱们代码中的多个线程随时都可能垮掉其中任何一个。而Thread.Interrupted()这个方法判定的标志位是Thread的static成员，即一个程序只有一个标志位。而Thread.currentThread().isInterrupted()判定的标志位是Thread的普通成员，每个示例都有自己的标志位！！

3.3 等待线程-join()

线程之间的执行顺序顺序是按照调度器来安排的，这个过程可以视为无序随机的。但是有些时候我们需要能够控制线程之间的顺序，我们需要等待一个线程完成它的工作后，才能进行自己的下一步工作。例如，张三只有等李四转账成功，才决定是否存钱，这时我们需要一个方法明确等待线程的结束。而join方法就是，当一个线程调用join时，这个线程就会阻塞等待，等到该线程执行完毕即对应线程的run方法执行完时开始执行下一个线程。

注意： 最先调用join方法的是 main线程，其他线程通过join可以让main线程后执行

join()的构造方法：

在这里插入图片描述

join操作默认情况下，就是要等待线程结束，即所谓的死等，显然这是非常不合理的。这时我们可以使用join方法的构造方法来设置等待的时间！如果在设置的时间到达后该线程还不结束，就直接返回执行下一个线程。

示例：

package ThreadTest;
//多线程能够提高任务完成的效率，但是使用多线程也要看具体场景，多线程适合CPU密集型的程序，需要进行大量计算的，这时使用多线程就可以充分利用CPU的多核资源
//注意：并不是说一个线程消耗600多ms，那两个线程就是消耗300多ms。这两个线程底层是并发执行还是并行执行是不确定的！
//注意：如果你计算的count比较小时，使用多线程也不一定会更快，因为创建线程也是需要消耗时间的
public class ThreadJoin {
    public static final long count = 10_0000_0000;

    public static void serial(){
        //开始时间
        long beg = System.currentTimeMillis();

        long a = 0;
        for (int i = 0; i < count; i++) {
            a++;
        }

        long b = 0;
        for (int i = 0; i < count; i++) {
            b++;
        }

        //结束时间
        long end = System.currentTimeMillis();

        System.out.println("串行执行消耗时间："+(end - beg) + "ms");
    }

    public static void concurrency() throws InterruptedException {
        long beg = System.currentTimeMillis();

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                long a = 0;
                for (int i = 0; i < count; i++) {
                    a++;
                }
            }
        });
        t1.start();

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                long b = 0;
                for (int i = 0; i < count; i++) {
                    b++;
                }
            }
        });
        t2.start();
        
        //在这里t1，t2都在执行 当t1，t2两个线程都结束 才会执行main线程
        //有个问题：由于线程调度是随机的，我们也不知道t1，t2到底谁先结束
        //假设t1先结束：先执行t1.join，等待t1结束后再执行t2.join，等t2结束后再执行main线程
        //假设t2先结束：先执行t1.join等待t1执行完，t2执行完了但是t1还没有结束，main线程任然阻塞在t1.join。过一会儿，t1结束了，执行t2.join，此时t2已经结束
        t1.join(10000);
        t2.join(10000);//在10秒钟等不到t1t2结束，main就不等了，如果不设置时间main就会死等

        //此处不能直接记录时间，求这个时间戳的代码是在main线程中
        //main 和 t1，t2之间是并发执行的关系，此处的t1，t2还没有执行完就开始记录时间显然是不正确的
        //正确做法是让main线程等待t1，t2线程执行完了后再记录时间
        //而前面的 join 就是等待线程结束，t1.join就是让main线程等待t1执行结束，此时main线程就进入阻塞状态，直到t1结束
        long end = System.currentTimeMillis();

        System.out.println("并发执行消耗时间："+ (end - beg) + "ms");
    }

    public static void main(String[] args) throws InterruptedException {
        serial();
        concurrency();
    }
}

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

方法	说明
public static Thread currentThread();	返回当前线程对象的引用

代码案例：

public class ThreadDemo {
    public static void main(String[] args) {
        Thread thread = Thread.currentThread();
        System.out.println(thread.getName());
    }
}