线程的常用属性及获取方法（2）

Youcan.

已于 2022-04-19 15:39:24 修改

阅读量699

点赞数 1

分类专栏： JavaEE Java 文章标签： java-ee java

于 2022-03-28 12:02:03 首次发布

本文链接：https://blog.csdn.net/m0_48273471/article/details/123789458

版权

Java 同时被 2 个专栏收录

76 篇文章 4 订阅

订阅专栏

JavaEE

41 篇文章 2 订阅

订阅专栏

线程的常用属性及获取方法（1）_小bit~的博客-CSDN博客

1. 线程ID

ID是线程的唯一标识，不同线程不会重复

2. 线程名称

名称是各种调试⼯具⽤到

3. 线程状态

状态表示线程当前所处的⼀个情况

4. 线程优先级

线程创建之后优先级就存在了。

优先级是int类型值，默认的优先级是5。线程的优先级1 - 10 ，最高的优先级是10 ，默认的优先级是 5 。

5. 是否守护线程

关于守护线程（后台线程），需要记住⼀点：JVM会在⼀个进程的所有⾮后台线程结束后，

才会结束运⾏。

  public static void main(String[] args) throws InterruptedException {
        // 得到当前的线程（main 主线程）
        Thread thread = Thread.currentThread();
        System.out.println(thread.getName() + "——是否是守护线程：" + thread.isDaemon());

        Thread t1 = new Thread(() -> {
            // 得到当前线程
            Thread cThread = Thread.currentThread();
            System.out.println(cThread.getName() + "——是否守护线程：" + cThread.isDaemon());
            // 创建子线程
            Thread tt1 = new Thread(() -> {
                Thread cThread2 = Thread.currentThread();
                System.out.println(cThread2.getName() + "——是否守护线程：" + cThread2.isDaemon());
            }, "子线程的子线程1");
            tt1.start();

        }, "子线程1");

        t1.start(); // 启动线程

        // 手动指定线程为守护线程
        t1.setDaemon(true);

        // 主线程休眠 1s
        Thread.sleep(1000);

    }

线程分类：

1. 用户线程（main默认用户线程）

2. 守护线程（后台线程）：为用户线程服务，当一个程序中所有的用户线程都结束之后，那么守护线程也会结束，获取当前线程是否为守护线程：Thread.isDaemon() ; true表示守护线程，false表示用户线程。

结论：

1. main线程（主线程）默认是非守护线程（用户线程）

2. 在用户线程中创建的子线程也是用户线程

3. 在守护线程中创建的子线程默认情况下也是守护线程

设置守护线程：

t1.setDaemon(true);

判断守护线程：

thread.isDaemon();

注意事项：

线程的类型（用户线程or守护线程）不能再线程运行期间，也就是调用了start之后进行设置，JVM会报错。

public class ThreadDemoByDaemon2 {
    public static void main(String[] args) {
        daemonThread();
    }

    /**
     * 用户线程
     */
    private static void daemonThread() {
        Thread t = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.println("用户线程执行：" + i);
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        //启动线程
        t.start();
    }

}

// 输出：
用户线程执行：0
用户线程执行：1
用户线程执行：2
用户线程执行：3
用户线程执行：4
用户线程执行：5
用户线程执行：6
用户线程执行：7
用户线程执行：8
用户线程执行：9

结论： JVM会等待所有的用户线程全部执行完成之后才退出。

public class ThreadDemoByDaemon2 {
    public static void main(String[] args) {
        userThread();
    }


    /**
     * 守护线程
     */
    private static void userThread() {
        Thread t = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.println("守护线程执行：" + i);
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        // 设置为守护线程
        t.setDaemon(true);
        //启动线程
        t.start();
    }
}

无输出结果

结论：JVM会等待所有的用户线程执行完之后，再退出，但不会等待守护线程执行完再退出。

守护线程VS用户线程：

用户线程在Java程序中比较重要，JVM一定要等所有的用户线程执行完之后才能自然结束，而守护线程是为用户线程服务的，所以当所有的用户线程都执行完之后，不管守护线程是否在执行，JVM都会退出。

6. 是否存活

是否存活，即简单的理解，为 run ⽅法是否运⾏结束了

public class ThreadDemoByAlive {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("1. 执行完了");
        });
        t.start();
        while(t.isAlive()) {
        }
        System.out.println("2. 确认执行完了");
    }
}

//输出:
1. 执行完了
2. 确认执行完了

7. 是否被中断

⽬前常⻅的有以下两种⽅式：

a. 通过⾃定义标记符来进⾏中断。

b. 调⽤ interrupt() ⽅法来中断。

a. ⾃定义标记符

public class ThreadInterrupt {
    // 1.声明一个自定义标识符
    private volatile static boolean flag = false;

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            while(!flag) {
                System.out.println("正在转账~");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("啊？差点误了大事！");
            }
        });

        thread.start();
        Thread.sleep(1000);
        // 终止线程
        System.out.println("有内鬼，终止交易");
        flag = true;
    }
}

//输出
正在转账~
有内鬼，终止交易
啊？差点误了大事！

b. 使⽤Interrupt()

使⽤ Thread.interrupted() 或者 Thread.currentThread().isInterrupted() 代替⾃定义标志位.

isInterrupted VS interrupted

a. interrupted：属于静态方法，所有程序都可以直接调用的全局方法，判断当前线程的中断标志位是否设置，调⽤后清除标志位。

b. isInterrupted：属于某个实例的方法。判断对象关联的线程的标志位是否设置，调⽤后不清除标志位。

对⽐代码如下：

public class ThreadInterrupt2 {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            System.out.println("终止标志位：" + Thread.currentThread().isInterrupted());
            while(!Thread.interrupted()) {
                System.out.println("正在转账。。。");
            }
            System.out.println("啊？险些误了大事！");
            System.out.println("终止标志位2：" + Thread.currentThread().isInterrupted());
            System.out.println("终止标志位2：" + Thread.currentThread().isInterrupted());
            System.out.println("终止标志位2：" + Thread.currentThread().isInterrupted());
            System.out.println();
            System.out.println("终止标志位4：" + Thread.interrupted());
            System.out.println("终止标志位4：" + Thread.interrupted());
            System.out.println("终止标志位4：" + Thread.interrupted());
        });

        thread.start();
        Thread.sleep(100);

        // 终止线程
        thread.interrupt();

        System.out.println("有内鬼，终止交易！");
    }
}

//输出：
终止标志位：false
正在转账。。。
正在转账。。。
正在转账。。。
正在转账。。。
正在转账。。。
正在转账。。。
正在转账。。。
正在转账。。。
有内鬼，终止交易！
啊？险些误了大事！
终止标志位2：false
终止标志位2：false
终止标志位2：false

终止标志位4：false
终止标志位4：false
终止标志位4：false

Process finished with exit code 0