【Java EE】多线程（二）Thread 类与常用方法

发布于：2024-05-05 ⋅ 阅读:(30) ⋅ 点赞:(0)

封面

📚博客主页：爱敲代码的小杨.

✨专栏：《Java SE语法》 | 《数据结构与算法》 | 《C生万物》 |《MySQL探索之旅》 |《Web世界探险家》

❤️感谢大家点赞👍🏻收藏⭐评论✍🏻，您的三连就是我持续更新的动力❤️

🙏小杨水平有限，欢迎各位大佬指点，相互学习进步！

文章目录

0. 前言

Thread 类是 JVM 用来创建和管理线程的类，也就是说每个线程都有唯一一个Thread 对象与之关联。

1. Thread 的常见构造方法

方法 作用
Thread() 创建线程对象
Thread(String name) 创建线程对象，并命名
Thread(Runnable target) 使用 Runnable 对象创建线程对象
Thread(Runnable target, String name) 使用 Runnable 对象创建线程对象，并命名 
class MyRunnable implements Runnable{
    @Override
    public void run() {

    }
}

public class demo1 {
    public static void main(String[] args) {
        Thread t1 = new Thread();
        System.out.println(t1.getName());

        Thread t2 = new Thread(new MyRunnable());
        System.out.println(t2.getName());

        Thread t3 = new Thread("t3线程");
        System.out.println(t3.getName());

        Thread t4 = new Thread(new MyRunnable(), "t4线程");
        System.out.println(t4.getName());
    }
}

运行结果：
image.png

2. Thread 类常见属性

属性 方法
ID getId()
名称 getName()
状态 getState()
优先级 getPriority()
是否后台线程 isDaemon()
是否存活 isAlive()
是否被中断 isInterruupted()

2.1 ID

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

public class demo2 {
    public static void main(String[] args) {
        Thread t1 = new Thread();
        System.out.println(t1.getName() + "ID:" + t1.getId());

        Thread t2 = new Thread("t2线程");
        System.out.println(t2.getName() + "ID:" + t2.getId());
    }
}

运行结果:
image.png
【注意】：这里的 ID 和 pcb 一一对应，但是这里的 ID 和 系统的中 pcb 上的 ID 是不同的体系（Java代码无法获取到 pcb 中的 ID），JVM 自己搞了一套 ID 体系

比如：我们去上班，在A公司，你的是工号xxxx，后来去到了B公司，你的工号是yyyy，人都是同一个人，在不同的体系中，工号就变了

2.2 名称

public class demo2 {
    public static void main(String[] args) {
        Thread t1 = new Thread();
        System.out.println(t1.getName());

        Thread t2 = new Thread("t2线程");
        System.out.println(t2.getName());

        Thread t3 = new Thread();
        t3.setName("t3线程"); // 设置线程名称
        System.out.println(t3.getName());
    }
}

运行结果:
image.png
如果线程没有命名, 默认为 Thread-0, Thread-1...

2.3 状态

后面具体介绍…（下集预告）

2.4 优先级

虽然 Java 提供了优先级接口，实际上就算修改了优先级，现象也不明显，修改了优先级是一回事，系统调度又是另一回事，这里的优先级只能是一个“建议参考”，具体还是系统以自身为准。
本质上还是因为调度这个事情，系统就一言堂了，我们很难干预到。

public class demo9 {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            while (true) {
                System.out.println("hello Thread1");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });

        Thread t2 = new Thread(() -> {
            while (true) {
                System.out.println("hello Thread2");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });

        t1.setPriority(Thread.MIN_PRIORITY); // 设置最低优先级
        t2.setPriority(Thread.MAX_PRIORITY); // 设置最高优先级

        t1.start();
        t2.start();
    }
}

运行结果：
image.png

image.png
从上图可以看出无论是否设置优先级，运行结果都差不多

2.5 是否后台线程

前台线程: 这种线程如果不运行结束的话, 此时 Java 进程是一定不会结束的
后台线程: 这样的线程, 即使继续在执行, 也不能阻止 Java 进程结束

举例: 酒桌文化
人物: 组局人(前台线程) 小杨(后台线程)
一桌人吃饭, 组局人(前台线程)可以掌握整个宴席(线程)的结束, 当组局人(前台线程)说宴席(线程)结束就结束了, 即使小杨(后台线程)还没有吃完,即使我还没有吃饱,也得撤了(当有多个组局人(多个前台线程)的时候, 当全部的组局人都不吃了, 宴席(线程)就结束了), 如果小杨先吃完,我想先溜(后台线程结束),我溜了对于整个宴席没有任何影响.
当全部的前台线程都结束了, 线程就结束了, 无论后台线程是否执行结束
当后台线程执行结束了, 要等到全部的前台线程结束, 线程才结束

在 Java 代码中, main 线程就是前台线程, 另外创建出来的线程也是前台线程, 可以通过 setDaemon 方法把线程设置为后台线程.
代码:

public class demo10 {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("hello Thread1");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });

        t1.setDaemon(true); // t1线程设置为后台线程

        t1.start();
    }
}

运行结果:
image.png

【注意】：此处也有一定概率，出现 t1 打印一次，然后结束进程的情况
这种情况就要看是 main 先执行结束，还是 t1 先执行打印1一次（线程之间是抢占式执行的，调度顺序是不确定的）

image.png

2.6 是否存活

是否存活: 指的是系统中(pcb) 是否还存在
Thread 对象的生命周期和 pcb 的生命周期是不一定完全一样的
image.png
代码:

public class demo11 {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("线程执行完毕!");
        });

        // 判断 t1线程是否存活
        System.out.println(t1.isAlive());

        t1.start();

        System.out.println(t1.isAlive());

        // 等待线程执行结束
        try {
            t1.join();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

        System.out.println(t1.isAlive());
    }
}

运行结果:
image.png

2.7 是否被中断

中断线程，在 Java 中，都只是“提醒”，“建议”，真正要不要终止，还得线程本体来进行决定的

t1线程正在执行，其他线程，只能提醒一下 t1 是不是要终止了，t1 收到这样的提醒之后，也还是得自己决定的

常见的方式以下两种：

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

示例一：

public class demo12 {
    private static boolean isRunning = true;

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            while (isRunning) {
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
            System.out.println("t1线程结束");
        });
        t1.start(); // 启动线程

        // 等待3s
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

        // 3s 后, 主线程修改 isRunning 的值,从而通知 t1 结束
        System.out.println("控制 t1 线程结束");
        isRunning = false;
    }
}

运行结果:
image.png
示例二：

public class demo13 {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
           while (!Thread.currentThread().isInterrupted()) {
               System.out.println("hello thread");
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   //throw new RuntimeException(e);
                   //e.printStackTrace();
                   System.out.println("线程即将结束");
                   break; // !!!注意此处的break
               }
           }
            System.out.println("t1线程结束");
        });

        t1.start();

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        t1.interrupt();
    }
}

运行结果:
image.png
Thread 收到通知的方式有两种：

  1. 如果线程因为调⽤ wait/join/sleep 等⽅法⽽阻塞挂起，则以 InterruptedException 异常的形式通知，清除中断标志
    • 当出现 InterruptedException 的时候, 要不要结束线程取决于 catch 中代码的写法. 可以选择忽略这个异常, 也可以跳出循环结束线程.
  2. 否则，只是内部的⼀个中断标志被设置，Thread 可以通过
    • Thread.currentThread().isInterrupted() 判断指定线程的中断标志被设置，不清除中断标志

这种方式通知收到的更及时，即使线程正在 sleep 也可以马上收到。

3. 启动线程-start()

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

举例

  • 重写 run() 方法是提供给线程要做的事情的指令清单
  • 线程对象可以认为是把 小杨、肯德滑稽叫过来点餐
  • 而调用 start() 方法,，就是喊一声“去制作吧”，线程才真正独立来执行

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

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布