【Java EE】-多线程编程(二) Thread类的几种方法+ wait和notify + 线程状态

已于 2023-04-28 19:05:47 修改
阅读量207 收藏 4
点赞数 4
分类专栏： 【JavaEE】 文章标签： java-ee java jvm
于 2023-03-31 23:58:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63979882/article/details/129545293
版权

作者：学Java的冬瓜
博客主页：☀冬瓜的主页🌙
专栏：【JavaEE】
分享：愉快骑行的一天！
主要内容：Thread方法的使用，终止一个线程interrupt，等待一个线程join、休眠一个线程sleep、控制线程执行顺序wait和notify。
线程的六大状态:NEW RUNNABLE TERMINATED TIMEWAITING WAITING BLOCKED

在这里插入图片描述

文章目录

一、Thread类的常用方法

1、Thread类的构造方法

注意：这样设置便于改线程名
在这里插入图片描述

2、Thread的几个常见属性

在这里插入图片描述

  • isDeamon()
    前台线程：会组织进程结束。只要前台线程还在运行，那么进程就不会结束，main以及我们手动创建的线程都是前台线程。可以用t.setDeamon()将前台线程改为后台线程。
    后台线程：也叫做守护线程，不会组织进程结束。即使守护线程还没运行完，进程也可以结束。
  • isAlive()
    isAlive 为true的条件是在PCB生命周期内。
    在创建了Thread对象后，t.start()前，由于操作系统内核还没有创建Thread对象对应的PCB，所以此时isAlive是false。
    在t.start()后，在操作系统内核中，真正创建了线程Thread对应的PCB，因此isAlive为 true。
    当创建好的PCB在内存执行完后(run方法走完)，PCB被销毁，此时isAlive 为false，而且此时PCB被销毁时，Thread对象可能还在。
    因为PCB创建前，和PCB销毁后，Thread对象都存在。因此，Thread对象比在内核中的PCB的生命周期长。
  • isInterrupted()
    判断线程是否中断。

3、获取当前线程 类方法currentThread()

public static Thread currentThread();

4、终止一个线程

@ 法一：使用标志位来控制线程是否停止

  • 比如以下代码：标志位取false，意味着告诉t线程，你要结束了。
    缺点：无法及时响应，比如下面代码，加上sleep是为了控制执行次序。当刚到第三秒时，会执行run()方法，打印完后到第四秒开始时，main和t抢占式执行，才能继续main线程执行flag=false，而run()方法执行完。这样其实浪费了这1s的时间，对于计算机来说，这是一个很长的时间。
// 线程中断 法一：利用标志位来控制线程是否停止
public class ThreadTest {
    private static boolean flag = true;  // flag为标志位

    public static void main(String[] args) {

        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                while (flag) {
                	System.out.println("Hello thread!");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        },"myThread");
        t.start();

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        flag = false;   // 标志位取false，意味着告诉t线程要结束了
    }
}

@ 法二：使用当前线程自带的标志位控制线程中断(终止)

  • 使用Thread.currentThread().isInterrupted()代替自定义标志位；使用t.interrupt()终止线程
    特点：线程可以随时响应并中断执行，可以唤醒sleep操作。比如如果t线程在sleep中休眠，t.interrupt()会把t线程唤醒，告诉t线程，你要结束了，具体方式是抛出异常。
// 使用Thread自带的表示位和方法，控制线程终止
public class ThreadTest {
    public static void main(String[] args) {
        Thread t = new Thread(()->
        {
            while (!Thread.currentThread().isInterrupted()){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("hello thread!");
            }
        });

        t.start();

        try {
            Thread.sleep(2300);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 终止t线程
        t.interrupt();
    }
}

// 结果
hello thread!
hello thread!
java.lang.InterruptedException: sleep interrupted
	at java.lang.Thread.sleep(Native Method)
	at ThreadTest.lambda$main$0(ThreadTest.java:8)
	at java.lang.Thread.run(Thread.java:748)
hello thread!
hello thread!
hello thread!
...

  • 分析：可以在运行时发现t线程被提前唤醒抛出异常，还有在抛出异常后"hello thread"会一直打印下去，请看以下分析：

  • 当执行到第三秒时，打印了两个"hello world!"，
    然后t线程休眠1s(其实只休眠了0.3)，main线程再休眠0.3s，然后执行t.interrupt()，这时很明显的看到异常很快(0.3s)抛出，也就是说，t线程本来要休眠一秒，但是t.interrupt()让它提前抛出异常了。

  • interrupt()会做两件事：
    1> 把线程内部的标志位设置成true
    2> 如果线程在sleep，就会触发异常，把sleep唤醒。

  • sleep被唤醒时，会做一件事：
    sleep被唤醒时，sleep会把标志位再设置回false(清空标志位)（wait，join等也有相应操作）。因此，抛出异常后，还会循环打印下去，所以上面的代码其实是t线程忽略了终止请求。接下来是三种类型：

  • 程序员可以根据自己的需求
    忽略终止请求
    立刻执行终止线程
    先执行其它任务再终止线程

三种情况核心代码如下：
在这里插入图片描述

在这里插入图片描述

5、等待一个线程 — join()

  • 操作系统调度线程是抢占式执行，谁先谁后不知道。而join可以控制两个线程的结束顺序：让调用join()的线程先执行完，其它线程阻塞。
  • 从以下代码和输出结果还有运行可以知道：
    在 t.join()前，t和main抢占式执行，所以"t——join之前"和第一个"hello thread"同时打印。
    在 t.join()后，先执行完 t，main才继续执行。t.join()其实就是让t线程调度，其它线程(比如main线程)进入阻塞，直到t线程执行完run方法，其它线程才继续往后执行。
    但是如果t.join()时，t线程已经结束，那t.join()就像是打游戏时空大了，其它线程并不会发生阻塞。
public class ThreadTest {
    public static void main(String[] args) {
        Thread t = new Thread(()->{
            for (int i = 0; i < 3; i++) {
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();
        System.out.println("t——join之前");
        try {
            t.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("t——join之后");
    }
}

结果：

t——join之前
hello thread
hello thread
hello thread
t——join之后
  • join()方法：
    在这里插入图片描述

6、休眠一个线程 类方法sleep()

public static void sleep(long millis);

理解：
在这里插入图片描述

二、wait和notify(Object类的方法)

1、wait和notify可以控制线程执行顺序，那是怎么控制的呢？

       来举个例子：比如 t1 t2两个线程要执行任务，要求
t1先执行的差不多了，再执行 t2。那此时，我们让 t2先wait（阻塞），等 t1执行的差不多了，再在 t1中通过 notify来通知
t2，把t2从阻塞中唤醒，继续执行 t2任务，这样就可以控制线程执行次序。
       当然，这个例子也可以用join完成，即在
t2线程run的第一行使用 t1.join()，就可以控制 t1在 t2前完成。但是当需求是
t1先执行50%，然后t2执行，那join就不能用了。而sleep不知道
t1执行50%具体消耗的时间，所以不能精确确定。然而，wait和notify就可以根据程序员自己决定。

2、wait和notify的使用方法

wait操作其实共要执行三个操作：
a> 释放锁
b> 进行阻塞等待
c> 收到notify的通知后，重新尝试获取锁，并且在获取锁后，继续往后执行。
在上面的操作中，还没获取锁，就想要阻塞等待，那就出问题了，所以报错：非法锁状态异常。

要求：t1先执行一半，再让 t2执行完，最后执行 t1的剩下的一半。

代码如下：

// wait 和 notify

public class Main {
    public static void main(String[] args) {
        Object object = new Object();
        Thread t1 = new Thread(()->{
            synchronized (object){
                try {
                    System.out.println("t1 wait之前");
                    object.wait();
                    System.out.println("t1 wait之后");

                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        Thread t2 = new Thread(()->{
            synchronized (object){
                System.out.println("t2 notify之前");
                object.notify();
                System.out.println("t2 notify之后");

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

结果：

t1 wait之前
t2 notify之前
t2 notify之后
t1 wait之后

需要注意的点：

  • a> wait和notify的对象必须是同一个。
    在这里插入图片描述

  • b> 在上面代码中，结果也可能为
    t2 notify之前
    t2 notify之后
    t1 wait之前
    然后就死等了
    因为在上面代码中t1和t2是抢占式执行的，我们无法确定谁先执行，如果是t2先执行，那t2先执行完前一半，然后notify就是空打了一炮，没有任何作用。然后就继续执行 t2剩下的一半，然后再调度到t1，执行t1的前一半，但是执行完t1的前一半后，t1就wait陷入死等了，没人将它唤醒。

  • c> 为了满足需求，让notify再wait之后执行，我们可以在t2最前面加上一个sleep，或者t1.start()和t2.start()中间加上sleep，那就可以大概率确保最开始是t1执行的。
    在这里插入图片描述
    在这里插入图片描述

  • d> 在上述代码中，wait是死等t2完成，t1才能完成剩下的一半，那我们可以给它传参，设置最大等待时间，如果超过这个等待时间，我们t1就会被唤醒。提前唤醒是正常操作，不会抛异常。但是interrupt唤醒sleep则是抛出异常。

  • e> 如果多个线程在阻塞等待object对象，此时有一个线程object.notify，那会唤醒任意一个在阻塞的线程(notifyAll则是唤醒全部正在阻塞的线程)。为了解决这样的问题，此时需要用到多个不同对象。

3、wait和notify小练习

要求：三个线程，使用notify，分别只能打印A,B,C，要保证是固定按照A、B、C的顺序打印的。

  • 使用两个对象加锁，每个对象供两个线程使用，连续的一个线程唤醒一个。具体代码如下：
public class Main {
    public static void main(String[] args) throws InterruptedException {
        Object o1 = new Object();
        Object o2 = new Object();
        Thread t1 = new Thread(()->{
            System.out.println("A");
            synchronized (o1){
                o1.notify();
            }
        });
        Thread t2 = new Thread(()->{
            synchronized (o1){
                try {
                    o1.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("B");
            synchronized (o2){
                o2.notify();
            }
        });
        Thread t3 = new Thread(()->{
            synchronized (o2){
                try {
                    o2.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("C");
            }
        });
        t2.start();
        t3.start();
        Thread.sleep(100);  // 保证t2和t3的wait先执行，t1的notify后执行
        t1.start();
    }
}

三、线程状态

1、线程的六大状态

NEW：创建了Thread对象，但还没有start(操作系统内核中还没有对应的PCB)
TERMINATED：内核中PCB已经执行完，但是对应的Thread对象还在。
RUNNABLE：可运行的。正在CPU上执行的PCB或者在就绪队列中的PCB（线程）。

以下都是阻塞下的状态：，此时PCB在阻塞队列中。
TIMED_WAITING：runnable中，调用sleep方法对应的状态
WAITING：runnable中，调用wait方法时对应的状态
BLOCKED：runnable中，加锁后对应的状态。

线程的状态：
在这里插入图片描述
NEW RUNNABLE TERMINATED状态演示：

// NEW RUNNABLE TERMINATED状态演示
public class ThreadTest {
    public static void main(String[] args) {
        Thread t = new Thread(()->{
            // 这个循环是确保start后，t获得RUNNABLE状态
            for (int i = 0; i < 1000000000; i++) {

            }
        });

        // start前，getState得到NEW状态
        System.out.println("start之前："+t.getState());
        t.start();
        // 在start后，getState得到RUNNABLE状态
        System.out.println("start之后，t调度执行时：" + t.getState());

        // 加sleep让t线程执行完，再getState，就可得到TERMINATED状态
        // （不用sleep，使用join也行）
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("t结束后：" + t.getState());
    }
}

start之前：NEW
start之后，t调度执行时：RUNNABLE
t结束后：TERMINATED

2、多线程的效率

  • 现在我们来看看，多线程和只有一个线程的执行效率的差别。在这之前我们先知道两个概念：
    CPU密集：包含了大量的 加减乘除 等运算。
    IO密集：包含读写文件，读写控制台，读写网络。比如启动eclipse时，需要加载数据，就涉及到大量的读写硬盘，阻塞了界面的响应，用多线程可以缓解。

业务：当前有两个变量，需要把两个变量各自自增100亿次(属于CPU密集)。代码如下：

// 演示单线程和多线程效率差别
public class ThreadTest {
    public static void main(String[] args) {
        serial();
        concurrency();
    }
	
	// 串行化
    public static void serial(){
        long begin = System.currentTimeMillis();

        long a = 0;
        for (long i = 0; i < 100_0000_0000L; i++) {  // int表示数据范围：-21亿~21亿，超过范围用long,且数值后加上L
            a++;
        }
        long b = 0;
        for (long i = 0; i < 100_0000_0000L; i++) {
            b++;
        }

        long end = System.currentTimeMillis();
        System.out.println("一个线程执行："+(end-begin)+"ms");
    }

	// 并发执行
    public static void concurrency(){  //concurrency:并发的
        Thread t1 = new Thread(()->{
            long a = 0;
            for (long i = 0; i < 100_0000_0000L; i++) {
                a++;
            }
        });

        Thread t2 = new Thread(()->{
            long b = 0;
            for (long i = 0; i < 100_0000_0000L; i++) {  // int表示数据范围：-21亿~21亿，超过范围用long,且数值后加上L
                b++;
            }
        });
        long begin = System.currentTimeMillis();
        t1.start();
        t2.start();

        // 确保t1和t2已经执行完
        try{
            t1.join();
            t2.join();
        }catch (Exception e){
            e.printStackTrace();
        }
		
		// 这时main从阻塞中恢复，继续执行下面代码：
        long end = System.currentTimeMillis();
        System.out.println("两个线程并发执行："+(end-begin)+"ms");
    }
}

运行结果：从运行结果中可以发现，多线程效率确实比单线程快很多。

// 第一次
一个线程执行：8429ms
两个线程并发执行：3856ms
// 第二次
一个线程执行：8657ms
两个线程并发执行：4009ms
// 第三次
一个线程执行：9168ms
两个线程并发执行：3591ms
学Java的冬瓜
关注
  • 4
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 9
    评论
专栏目录
Java多线程编程Thread类的使用和注意事项
weixin_46429649的博客
06-15 406
Thread类的基本用法： } 线程的一些指标：run和start的区别中断线程 线程等待Thread.currentThread() 进程状态针对系统层面：java中Thread类进一步细化：状态转换图： 线程安全问题： 线程不安全产生的原因：内存可见性解决方法：synchronized用法1.直接修饰普通的方法 2.修饰一个代码块 3.修饰一个静态方法 或者 监视器锁monitor lock 死锁的其他场景死锁的四个必要条件（前三个都是锁本身的特点）java线程类：volatile
浅谈java多线程wait，notify
08-25
主要介绍了java多线程wait，notify，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，下面小编和大家一起来学习一下吧
JavaEE-多线程wait和notify都有哪些区别？wait和sleep都有哪些区别？
xyk：的博客
03-27 777
本篇文章将详细讲述wait和notify的区别，由于线程之间是抢占式执行的, 因此线程之间执行的先后顺序难以预知，但是实际开发中有时候我们希望合理的协调多个线程之间的执行先后顺序wait：让当前线程进入等待状态 notify：唤醒在当前对象上等待的线程 注意: wait, notify, notifyAll 都是 Object 类的方法. wait和notify一定要搭配synchronized来使用，没有synchronized会抛出异常！！！
多线程编程-wait()与notify()
zcx777123的博客
01-24 988
由于线程之间是抢占式执行的，因此线程之间的执行先后顺序总是难以预知的。但是实际开发中我们总是希望能够合理的协调多个线程之间的执行先后顺序。wait()/wait(long timeout)：让当前的线程进入等待状态；notify()/notifyAll()：唤醒当前的对象上等待的那个线程；wait()、wait(long timeout)、notify()、notifyAll()都是Object类的方法。
java多线程编程_Thread类_线程状态的理解
bug郭的博客
04-23 1550
本节目标 学习java多线程编程! 了解java中的Thread类的基本使用! 掌握Thread创建线程对象的5种方法 学习Thread类中的一些常用属性和方法! Thread类 我们知道操作系统中的线程是并发执行的! 而Thread类是java给我们提供的一个类,通过Thread可以实现java并发编程!Thread类可以视为java标准库提供的API 创建好的Thread实例和操作系统的线程一一对应!!! Thread是在java.lang包下的类无需导入!!! 了解并发编程 publi
【Java EE】-多线程编程(七) 多线程案例之定时器
m0_63979882的博客
04-07 340
定时器的概念，只用标准库提供的定时器。自定义计时器需要注意的点以及相应的分析。最后是自定义的定时器实现代码。
Java多线程(2)---线程控制和线程安全的详细讲解
tq02的博客
08-09 1448
本文讲解的是多线程的控制方法和线程安全。控制线程的sleep()、interrupt()、wait()等方法，线程安全的原因以及解决方法。
JavaEE(系列7) -- 多线程(wait 和 notify 的使用)
小白的博客
05-18 468
内存可见性+wait notify
java EE初阶 — wait 和 notify
超烦豆先森
12-08 461
java 多线程 wait 和 notify
【Java 多线程】多线程带来的的风险-线程安全、多线程五个经典案例
热门推荐
1226
04-01 1万+
日常开发中如果用到多线程编程，也一定会涉及到线程安全问题 线程安全这个问题就不太好理解 正因为如此，程序猿们才尝试发明出更多的编程模型来处理并发编程的任务 例如：多进程、多线程、actor、csp、async+await、定时器+回调 操作系统，调度线程的时候，是随机的 (抢占式执行) 正式因为这样的随机性，就可能导致程序的执行出现一些 bug 如果因为这样的调度随机性引入了 bug，就认为代码是线程不安全的，如果是因为这样的调度随机性，也没有带来 bug，就认为代码是线程安全的 这里的线程安全指的是有.
Java多线程通信wait()和notify()代码实例
08-19
主要介绍了Java多线程通信wait()和notify()代码实例,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Java多线程通讯之wait,notify的区别详解
08-27
主要介绍了Java多线程通讯之wait,notify的区别详解，非常不错，具有一定的参考借鉴借鉴价值,需要的朋友可以参考下
Java多线程基础 线程的等待与唤醒(wait、notify、notifyAll)
08-30
主要介绍了Java多线程基础 线程的等待与唤醒,需要的朋友可以参考下
Java多线程中wait、notify、notifyAll使用详解
08-26
主要介绍了Java多线程中wait、notify、notifyAll使用详解，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
【JavaEE】多线程(1)
HD_13的博客
05-31 1234
线程(Thread)是一个轻量级进程,与"进程"相比在创建和销毁上的开销更小,主要原因是:一个进程被创建 系统会给进程分配资源,而一个进程可以有多个线程,这些线程不需要独自一个一个被系统分配资源,它们可以共享系统为进程分配的资源,在销毁的时候也只需要销毁进程的资源即可,这样下来减少了创建与销毁的开销,线程不仅共享进程的资源,而且每一个线程都有自己的属性.后台线程：后台线程结束了，不会影响整个线程的进度，但前台线程结束了，整个线程就结束了，那么自然后台线程也就结束了。
【JavaEE】JVM中内存区域划分和类加载机制详解
m0_74105656的博客
05-31 692
JVM中的内存区域划分和类加载机制的详解
JAVAEE之文件IO_数据流概念，字节流：InputStream、OutputStream，字符流：reader、writer，及实例代码
最新发布
2301_80653026的博客
05-31 876
 顾名思义，I 表示input，O 表示output，也就是输入输出流，主要是在程序与文件之间，用于传输数据的通道。既然要传输数据，那么我们需要理解文件和程序之间哪种方向的传输是输入流，哪种传输作为输出流？我们可以举一个例子，如下图所示:  IO 流是 Java IO 中的核心概念。流是在概念上表示无穷无尽的数据流。IO 流连接到数据源或数据的目的地，连接到数据源的叫输入流，连接到数据目的地的叫输出流。Java 程序不能直接从数据源读取和向数据源写入，只能借助 IO 流从输入流中读取数据，向输出流中写入数
【JavaEE】Servlet
2301_79765510的博客
05-29 466
Servlet 详解
java多线程之 wait和notify
06-28
Java中的wait和notify是多线程编程中的两个重要方法，用于线程之间的协作和通信。 wait方法可以使当前线程进入等待状态，直到其他线程调用notify或notifyAll方法唤醒它。在调用wait方法时，当前线程会释放它所持有...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

学Java的冬瓜

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值