java多线程：详解线程唤醒和阻塞的五种常用方法，sleep,suspend和 resume,wait和 notify,yield,join

最新推荐文章于 2024-08-02 10:45:00 发布
最新推荐文章于 2024-08-02 10:45:00 发布
阅读量2.2k 收藏 10
点赞数 2
分类专栏： java 文章标签： java 多线程 sleep wait notify
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44096448/article/details/102860078
版权

1. sleep() 方法：

sleep（毫秒），指定以毫秒为单位的时间，使线程在该时间内进入线程阻塞状态，期间得不到cpu的时间片，等到时间过去了，线程重新进入可执行状态。（暂停线程，不会释放锁，睡眠结束，线程继续执行，线程自动释放锁）

public class ThreadTest {

    public static void test() {

        new Thread (() -> {
            synchronized (ThreadTest.class) {
                System.out.println ("线程一获得了ThreadTest对象锁");
                try {
                    Thread.sleep (5000L);
                } catch (InterruptedException e) {
                    e.printStackTrace ();
                }
                System.out.println ("执行结束自动释放锁");
            }
        }).start ();

        new Thread (() -> {
            try {
                Thread.sleep (1000L);
            } catch (InterruptedException e) {
                e.printStackTrace ();
            }
            synchronized (ThreadTest.class) {
                System.out.println ("线程二获得了ThreadTest对象锁");
            }
        }).start ();

    }

    public static void main(String[] args) {
        test ();
    }
}

控制台输出：

  • 线程一获得了ThreadTest对象锁
  • 执行结束自动释放锁
  • 线程二获得了ThreadTest对象锁

分析：由于线程一率先获得了对象锁，开始执行sleep方法，此时线程一处于阻塞状态，而sleep并不会释放锁。导致线程二未能拿到锁，线程二处于阻塞状态。等待线程一睡眠时间完毕，线程一继续运行，线程一执行完毕自动释放锁，线程二成功获得对象锁，开始执行线程二同步代码块。

2.suspend() 和 resume() 方法：

挂起和唤醒线程，suspend()使线程进入阻塞状态，只有对应的resume()被调用的时候，线程才会进入可执行状态。（suspend不会释放锁，等待resume唤醒，线程继续执行，执行完毕，自动释放锁，不建议用，容易发生死锁，该方法已被JDK弃用）

suspend() 

import java.util.concurrent.TimeUnit;

public class ThreadTest {

    public static void test() {

        Thread t1 = new Thread (() -> {
            synchronized (ThreadTest.class) {
                System.out.println ("线程一获得了ThreadTest对象锁");
                try {
                    TimeUnit.SECONDS.sleep (2);
                } catch (InterruptedException e) {
                    e.printStackTrace ();
                }
                System.out.println ("执行结束自动释放锁");
            }
        });
        Thread t2 =  new Thread (() -> {
            try {
                TimeUnit.SECONDS.sleep (1);
            } catch (InterruptedException e) {
                e.printStackTrace ();
            }
            synchronized (ThreadTest.class) {
                System.out.println ("线程二获得了ThreadTest对象锁");
            }
        });

        t1.start ();
        t2.start ();
        try {
            System.out.println ("主线程休眠1秒钟");
            TimeUnit.SECONDS.sleep (1);
        } catch (InterruptedException e) {
            e.printStackTrace ();
        }
        t1.suspend ();
        System.out.println ("线程一被挂起");
    }

    public static void main(String[] args) {
        test ();
    }
}

控制台输出：

  • 主线程休眠1秒钟
  • 线程一获得了ThreadTest对象锁
  • 线程一被挂起

分析：由于线程一率先获得了对象锁，而suspend并不会释放锁，如果没被resume唤醒，程序出现死锁，线程二无法获得对象锁，永远不会被执行。

resume() 

import java.util.concurrent.TimeUnit;

public class ThreadTest {

    public static void test() {

        Thread t1 = new Thread (() -> {
            synchronized (ThreadTest.class) {
                System.out.println ("线程一获得了ThreadTest对象锁");
                try {
                    TimeUnit.SECONDS.sleep (2);
                } catch (InterruptedException e) {
                    e.printStackTrace ();
                }
                System.out.println ("线程一被唤醒");
                System.out.println ("执行结束自动释放锁");
            }
        });
        Thread t2 =  new Thread (() -> {
            try {
                TimeUnit.SECONDS.sleep (1);
            } catch (InterruptedException e) {
                e.printStackTrace ();
            }
            synchronized (ThreadTest.class) {
                System.out.println ("线程二获得了ThreadTest对象锁");
            }
        });

        t1.start ();
        t2.start ();
        try {
            System.out.println ("主线程休眠1秒钟");
            TimeUnit.SECONDS.sleep (1);
        } catch (InterruptedException e) {
            e.printStackTrace ();
        }
        t1.suspend ();
        System.out.println ("线程一被挂起");
        t1.resume ();
    }

    public static void main(String[] args) {
        test ();
    }
}

控制台输出：

  • 主线程休眠1秒钟
  • 线程一获得了ThreadTest对象锁
  • 线程一被挂起
  • 线程一被唤醒
  • 执行结束自动释放锁
  • 线程二获得了ThreadTest对象锁

分析：由于线程一率先获得了对象锁，接着线程一被挂起，线程一阻塞，并没有释放锁，等待被唤醒，线程二没有拿到锁，处于阻塞状态，直到主线程执行resume，线程一被成功唤醒，线程一执行结束释放锁，线程二拿到锁，执行同步代码块。

3.wait() 和 notify() 方法：

两个方法搭配使用，wait()使线程进入阻塞状态，调用notify()时，线程进入可执行状态。wait()内可加或不加参数，加参数时是以毫秒为单位，当到了指定时间或调用notify()方法时，进入可执行状态。（属于Object类，而不属于Thread类，wait()会先释放锁，再执行等待的动作。由于wait()所等待的对象必须先锁住，因此，它只能用在同步化程序段或者同步化方法内，否则，会抛出异常IllegalMonitorStateException.）

wait()

import java.util.concurrent.TimeUnit;

public class ThreadTest {
    private static ThreadTest lock = new ThreadTest ();

    public static void test() {

        new Thread (() -> {
            synchronized (lock) {
                System.out.println ("线程一获得了ThreadTest对象锁");
                try {
                    lock.wait ();
                } catch (InterruptedException e) {
                    e.printStackTrace ();
                }
                System.out.println ("执行结束自动释放锁");
            }
        }).start ();

        new Thread (() -> {
            try {
                TimeUnit.SECONDS.sleep (1);
            } catch (InterruptedException e) {
                e.printStackTrace ();
            }
            synchronized (lock) {
                System.out.println ("线程二获得了ThreadTest对象锁");
            }
        }).start ();

    }

    public static void main(String[] args) {
        test ();
    }
}

控制台输出：

  • 线程一获得了ThreadTest对象锁
  • 线程二获得了ThreadTest对象锁

分析：由于线程一率先获得了对象锁，执行同步代码块，wait方法被执行，线程一处于等待状态，由于wait方法会先释放对象锁，线程二成功获得锁，执行同步代码块。

notify()

import java.util.concurrent.TimeUnit;

public class ThreadTest {
    private static ThreadTest lock = new ThreadTest ();

    public static void test() {

        new Thread (() -> {
            synchronized (lock) {
                System.out.println ("线程一获得了ThreadTest对象锁");
                try {
                    lock.wait ();
                } catch (InterruptedException e) {
                    e.printStackTrace ();
                }
                System.out.println ("线程一被唤醒成功");
            }
        }).start ();

        new Thread (() -> {
            try {
                TimeUnit.SECONDS.sleep (1);
            } catch (InterruptedException e) {
                e.printStackTrace ();
            }
            synchronized (lock) {
                System.out.println ("线程二获得了ThreadTest对象锁");
                lock.notify ();
            }
        }).start ();

    }

    public static void main(String[] args) {
        test ();
    }
}

控制台输出：

  • 线程一获得了ThreadTest对象锁
  • 线程二获得了ThreadTest对象锁
  • 线程一被唤醒成功

分析：由于线程一率先获得了对象锁，接着执行wait方法，处于等待状态，wait方法会自动释放锁，线程二拿到锁，执行notify方法，线程一被唤醒成功，线程一继续运行。

4. yield() 方法：

该方法与sleep()类似，只是不能由用户指定暂停多长时间，但此时线程任然处于可执行状态，随时可以再次分得cpu时间片。yield()方法只能使同优先级的线程有执行的机会。（暂停当前正在执行的线程，并执行其他线程，且让出的时间不可知，不会释放锁）

yield()

import java.util.concurrent.TimeUnit;

public class ThreadTest {
    private static ThreadTest lock = new ThreadTest ();

    public static void test() {

        new Thread (() -> {
            synchronized (lock) {
                System.out.println ("线程一获得了ThreadTest对象锁");
                Thread.yield ();
                try {
                    TimeUnit.SECONDS.sleep (2);
                } catch (InterruptedException e) {
                    e.printStackTrace ();
                }
                System.out.println ("执行结束自动释放锁");
            }
        }).start ();

        new Thread (() -> {
            try {
                TimeUnit.SECONDS.sleep (1);
            } catch (InterruptedException e) {
                e.printStackTrace ();
            }
            synchronized (lock) {
                System.out.println ("线程二获得了ThreadTest对象锁");
            }
        }).start ();

    }

    public static void main(String[] args) {
        test ();
    }
}

控制台输出：

  • 线程一获得了ThreadTest对象锁
  • 执行结束自动释放锁
  • 线程二获得了ThreadTest对象锁

分析：由于线程一率先获得了对象锁，执行yield方法，线程一任然处于可执行状态，但yield方法并不释放锁，所以线程二还是处于阻塞状态，等待线程一执行完毕，线程二获得对象锁，线程二执行同步代码块。

5.join()方法：

当主线程开启一个或多个子线程的时候，使用join方法，必须等该线程运行结束，主线程或其他子线程才由阻塞状态转为可执行状态。

join()

import java.util.concurrent.TimeUnit;

public class ThreadTest {
    private static ThreadTest lock = new ThreadTest ();

    public static void test() {

        Thread t1 = new Thread (() -> {
            for (int i = 0; i < 5; i++) {
                System.out.println ("A----" + i);
            }
        });

        Thread t2 = new Thread (() -> {
            for (int j = 0; j < 5; j++) {
                System.out.println ("B----" + j);
            }
        });

        t1.start ();
        try {
            t1.join ();
        } catch (InterruptedException e) {
            e.printStackTrace ();
        }
        t2.start ();

    }

    public static void main(String[] args) {
        test ();
    }
}

控制台输出：

  • A----0
  • A----1
  • A----2
  • A----3
  • A----4
  • B----0
  • B----1
  • B----2
  • B----3
  • B----4

分析：主线程开始运行t1线程，接着join方法被调用，主线程处于阻塞状态，等待t1线程执行完毕，主线程状态变为可运行状态，t2线程被执行。

6.总结：以上是Java线程唤醒和阻塞的五种常用方法，不同的方法有不同的特点，其中wait() 和 notify()是其中功能最强大、使用最灵活的方法，但这也导致了它们效率较低、较容易出错的特性，因此，在实际应用中应灵活运用各种方法，以达到期望的目的与效果

小伙子。
关注
专栏目录
线程的阻塞和唤醒
chunyusi1569的博客
08-04 1289
Java的线程阻塞和唤醒是通过Unsafe类的park和unpark方法做到的。 两个方法都是native方法，本身由c实现的核心功能。 park：是让当前运行的线程Thread.currentThread()休眠。 unpark：是唤醒指定线程。 两个方法底层使用操作系统提供的信号量机...
java suspend wait_java中线程阻塞之sleep、suspend、wait、resume、notify方法解析
weixin_42306002的博客
02-16 999
java线程的5状态包括create、runnable、running、blocked、dead。create是指用new线程被创建，但是还没有准备好各种资源。runnable是指使用start启动线程，这时java线程的5状态包括create、runnable、running、blocked、dead。create是指用new线程被创建，但是还没有准备好各种资源。runnable是指使用star...
java中的wait和sleep
qq_61139806的博客
10-20 2160
Java中线程的状态分为 6 种： 初始(NEW)：新建了一个线程对象，但是还没调用start() 方法 运行(RUNNABLE)：Java 线程中将就绪（ready）和运行中（running）两种状态统称为“运行”。线程对象在创建之后，其他线程(比如 main 线程)调用了该对象的 start() 方法，该状态的线程位于可变线程池中，等待被线程调度选中，获取CPU 的使用权，此时处于就绪状态(ready)。就绪状态的线程在获得 CPU时间片后变为运行状态(running)。 阻塞(BLOCKED)：表示
Java线程阻塞
技术博客
11-16 1万+
阻塞指的是暂停一个线程的执行以等待某个条件发生（如某资源就绪），学过操作系统的同学对它一定已经很熟悉了。Java 提供了大量方法来支持阻塞，下面让我们逐一分析。　　1. sleep() 方法：sleep() 允许 指定以毫秒为单位的一段时间作为参数，它使得线程在指定的时间内进入阻塞状态，不能得到CPU 时间，指定的时间一过，线程重新进入可执行状态。　　典型地，sleep() 被用在等待某个资源就绪
JAVA --- sleep、join、yield方法有什么区别？
最新发布
xycxycooo的博客
08-02 358
sleep方法：用于让当前线程暂停执行一段指定的时间，不会释放锁，时间到了自动唤醒。join方法：用于等待调用该方法的线程终止，可以带超时参数，用于线程之间的同步。yield方法：用于提示调度器当前线程愿意让出CPU时间片，不会释放锁，不会导致线程进入睡眠或等待状态。
线程休眠与唤醒
m0_48273471的博客
04-12 2567
wait/notify 随机唤醒问题、线程休眠和指定唤醒：LockSupport、LockSupport 和 Interrupt、LockSupport VS wait
线程阻塞等待和唤醒（wait和notify）
m0_57524066的博客
06-24 577
由于线程之间执行都是抢占式执行，无序的，所以在有些情况下我们希望多个线程之间能够有序的执行，所以这里我们要说的是wait()和notify()方法实现线程之间的阻塞等待以及唤醒该线程执行
java 线程 状态 图_Java线程中的生命周期和状态控制图文详解
weixin_29999895的博客
02-21 230
这篇文章主要介绍了Java线程的生命周期和状态控制,需要的朋友可以参考下一、线程的生命周期线程状态转换图：1、新建状态用new关键字和Thread类或其子类建立一个线程对象后，该线程对象就处于新生状态。处于新生状态的线程有自己的内存空间，通过调用start方法进入就绪状态(runnable)。注意：不能对已经启动的线程再次调用start()方法，否则会出现Javalang.IllegalThrea...
java多线程与并发编程详解
刘成
03-17 4255
一、多线程1、操作系统有两个容易混淆的概念，进程和线程。进程：一个计算机程序的运行实例，包含了需要执行的指令；有自己的独立地址空间，包含程序内容和数据；不同进程的地址空间是互相隔离的；进程拥有各种资源和状态信息，包括打开的文件、子进程和信号处理。线程：表示程序的执行流程，是CPU调度执行的基本单位；线程有自己的程序计数器、寄存器、堆栈和帧。同一进程中的线程共用相同的地址空间，同时共享进进程锁拥有的...
面试题汇总二 Java 多线程篇
u013575592的博客
10-16 1289
前言 题目汇总来源史上最全各类面试题汇总，没有之一，不接受反驳 面试题汇总一 Java 语言基础篇 面试题汇总二 Java 多线程篇 面试题汇总三 Java 集合篇 面试题汇总四 JVM 篇 面试题汇总五 Spring 篇 面试题汇总六 数据库篇 面试题汇总七 计算机网络篇 目录 前言 多线程 开启线程的三种方式？ 什么是Callable和Future? 说说进程...
专栏总结java4：线程和线程池
黄规速博客:学如逆水行舟，不进则退
08-18 458
专栏总结java4：异常
最详细的多线程讲解！
GD_YuZhe的博客
07-23 546
线程、进程、并发、并行 1、线程与进程 线程也被称作轻量级进程，线程是进程的执行单元； 线程是进程的组成部分，一个进程可以拥有多个线程，一个线程必须有一个父进程； 2、并发与并行 并发：指在同一时刻只能有一条指令执行，但多个进程指令被快速轮换执行，使得在宏观上具有多个进程同时执行的效果； 并行：指在同一时刻，有多条指令在多个处理器上同时执行； 创建线程的两种方式 1、继承Thread类创建线程类 通过继承Thread类来创建并启动多线程的步骤如下： 定义Thread类的子类，并重写该类的
Java多线程之常用的相关方法总结（线程停止、线程休眠、线程礼让、线程优先级、守护线程等等）
熊凯瑞的博客
12-05 937
setPriority(int newPriority) 更改线程的优先级 static void sleep(long millis) 在指定的毫秒数内让当前正在执行的线程休眠 void join() 等待该线程终止 static void yield() 暂停当前正在执行的线程对象，并执行其他线程 void interrupt() 中断线程，别用这个方式 boolean isAliv
第二部分 线程的等待和唤醒
小崔的博客
01-13 1万+
<br /><br /><br /><br /><br />从这个图中可以看出，等待状态是一种特殊的状态。使线程陷入等待实际上是暂时剥夺线程当前拥有的CPU时间片和获取CPU时间片的资格，使其返回到就绪状态。除非被唤醒，否则等待时间已满，该线程将一直等待。不会被JVM线程调度器选中并赋予CPU时间片。处于等待的线程一旦恢复执行，与其他处于就绪状态被线程调度器选中的线程不同，将从上次结束执行的断点处开始执行，而非从头开始。<br /> 使线程中断运行，返回就绪状态的手段是调用java.lang.Object对
多线程-线程安排-休眠与唤醒
彼岸迷离博客
08-18 559
package com.liujinghe.lianxi1.a_thread; import java.util.Set; class Message{ //创建一个类，这个类的对象当成一个锁对象来看待 private String message; public Message() { // TODO Auto-generated constructor stub } public Message(String message) { ...
线程的等待和唤醒机制
weixin_38568503的博客
03-15 6606
三种让线程等待和唤醒的方法： LockSupport类可以阻塞当前线程以及唤醒指定被阻塞的线程： 第一种方式：synchronized + wait + notify： 即使用Object中的wait方法让线程等待，使用Object中的notify方法唤醒线程： 代码演示： 存在的弊端： 问题一： 报异常，证明 wait + notify不能脱离synchronized 代码块或者方法。 问题二： 被阻塞的结果，证明wait + notify顺序不能颠倒，只能先等待后唤醒。等待中的线程才能.
线程通讯方式-----休眠唤醒
qq_34270873的博客
02-18 136
线程通讯方式 线程间通信常用方式如下: 1.Object的**wait**、**notify**、**notifyAll** 2.Condition的**await**、**signal**、**signalAll** 3.CountDownLatch：用于某个线程A等待若干个其他线程执行完之后，它才执行 4.CyclicBarrier：一组线程等待至某个状态之后...
Java如何实现线程唤醒与阻塞
ysds20211402的博客
02-08 316
转自：微点阅读https://www.weidianyuedu.com/content/2817496690733.html 如果线程是因为调用了wait()、sleep()或者join()方法而导致的阻塞，可以中断线程，并且通过抛出InterruptedException来唤醒它；如果线程遇到了IO阻塞，无能为力，因为IO是操作系统实现的，Java代码并没有办法直接接触到操作系统。以下是详细的唤醒方法： 1. sleep()方法： sleep（毫秒），指定以毫秒为单位的时间，使线程在该时间...
REDIS6_分布式存储极致性能目录
热门推荐
所得皆惊喜
10-21 2万+
缓存从入门到源码的深入交流中！！！
java中resume和suspend
06-09
`resume()`和`suspend()`是Java中线程控制的方法，但它们已经被标记为过时的方法，不再推荐使用。 `suspend()`方法用于暂停线程的执行，直到调用`resume()`方法。这会导致线程被挂起，但是它会保留锁定和其他资源，这可能会导致死锁或其他线程安全问题。这个方法已经被废弃，因为它的使用可能会导致应用程序在运行过程中出现不可预测的行为。 `resume()`方法用于恢复通过`suspend()`方法暂停的线程的执行。然而，这个方法也已经被废弃，因为它存在风险，可能会导致应用程序在运行过程中出现不可预测的行为。 在Java中，可以使用`wait()`和`notify()`方法来实现线程的暂停和恢复。这两个方法是线程安全的，可以在多线程应用程序中安全地使用。`wait()`方法会将线程放入等待状态，直到另一个线程调用`notify()`方法，通知它继续执行。`notify()`方法则会唤醒一个等待的线程，使其继续执行。 因此，建议使用`wait()`和`notify()`方法来控制线程的执行，而不是使用已被废弃的`suspend()`和`resume()`方法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值