Java 并发编程学习总结：实现线程等待和唤醒的方法

已于 2024-10-18 08:41:06 修改
阅读量836 收藏 8
点赞数 18
文章标签： java 开发语言
于 2024-10-14 19:23:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kwok924/article/details/142926538
版权

本文是学习尚硅谷周阳老师《JUC并发编程》的总结（文末有链接）。

在 Java 并发编程：实现线程等待和唤醒有 3 种方法：

  • Object 类的 wait/notify 方法
  • Condition 类的 await/signal 方法
  • LockSupport 类的 park/unpark 方法

Object 类的 wait/notify 方法

实现代码：

package juc;

import java.util.concurrent.TimeUnit;

public class LockSupportDemo {
    public static void main(String[] args)
    {
        Object objectLock = new Object();

        new Thread(() -> {
            synchronized (objectLock) {
                System.out.println(Thread.currentThread().getName() + " come in");
                try {
                    objectLock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " 被唤醒");
            }
        }, "t1").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> {
            synchronized (objectLock) {
                System.out.println(Thread.currentThread().getName() + " come in");
                objectLock.notify();
                System.out.println(Thread.currentThread().getName() + " 发出通知");
            }
        }, "t2").start();
    }
}

注意：

  • wait 和 notify 方法必须要在同步块或同步方法里面，且成对出现使用
  • 必须先 wait 后 notify

Condition 类的 await/signal 方法

实现代码：

package juc;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockSupportDemo {
    public static void main(String[] args)
    {
        Lock lock = new ReentrantLock();
        Condition condition = lock.newCondition();

        new Thread(() -> {
            lock.lock();
            try {
                System.out.println(Thread.currentThread().getName() + " come in");
                condition.await();
                System.out.println(Thread.currentThread().getName() + " 被唤醒");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }, "t1").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> {
            lock.lock();
            try {
                System.out.println(Thread.currentThread().getName() + " come in");
                condition.signal();
                System.out.println(Thread.currentThread().getName() + " 发出通知");
            } finally {
                lock.unlock();
            }
        }, "t2").start();
    }
}

注意：

  • await 和 signal方法必须先获取锁，即在 lock/unlock 对里面才能使用
  • 必须先 await 后 signal

LockSupport 类的 park/unpark 方法

上述两种方法在使用时都有如下限制：

  • 线程要先获得并持有锁，必须在锁块（synchronized 或 lock）中
  • 必须要先等待再唤醒，线程才能够被唤醒

因此才出现了 LockSupport 类，通过此类可以不受上面的限制更方便地实现线程等待和唤醒。

LockSupport 是一个线程阻塞工具类，所有的方法都是静态方法，可以让线程在任意位置阻塞，阻塞之后也有对应的唤醒方法，底层调用的是 UnSafe 类的 native 代码。

LockSupport 提供 park() 和 unpark() 方法提供阻塞线程和唤醒线程的功能。

实现代码：

package juc;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.LockSupport;
import java.util.concurrent.locks.ReentrantLock;

public class LockSupportDemo {
    public static void main(String[] args)
    {
        Thread t1 = new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + " come in");
            LockSupport.park();
            System.out.println(Thread.currentThread().getName() + " 被唤醒");
        }, "t1");
        t1.start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + " come in");
            LockSupport.unpark(t1);
            System.out.println(Thread.currentThread().getName() + " 发出通知");
        }, "t2").start();
    }
}

通过 LockSupport 类可以先 unpark 给 t1 线程颁发许可证，等到 t1 运行到 park 时直接放行通过，不会阻塞。

package juc;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.LockSupport;
import java.util.concurrent.locks.ReentrantLock;

public class LockSupportDemo {
    public static void main(String[] args)
    {
        Thread t1 = new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName() + " come in");
            LockSupport.park();
            System.out.println(Thread.currentThread().getName() + " 被唤醒");
        }, "t1");
        t1.start();



        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + " come in");
            LockSupport.unpark(t1);
            System.out.println(Thread.currentThread().getName() + " 发出通知");
        }, "t2").start();
    }
}

输出：

t2 come in
t2 发出通知
t1 come in
t1 被唤醒

Process finished with exit code 0

LockSupport 和每个使用它的线程都有一个许可（permit）关联，每个线程都有一个相关的 permit ，permit 最多只有 1 个，重复调用 unpark() 也不会累积 permit。

可以通过如下代码验证：

package juc;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.LockSupport;
import java.util.concurrent.locks.ReentrantLock;

public class LockSupportDemo {
    public static void main(String[] args)
    {
        Thread t1 = new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName() + " come in");
            LockSupport.park();
            System.out.println(Thread.currentThread().getName() + " 通过第1个park");
            LockSupport.park();
            System.out.println(Thread.currentThread().getName() + " 通过第2个park");
            System.out.println(Thread.currentThread().getName() + " 被唤醒");
        }, "t1");
        t1.start();



        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + " come in");
            LockSupport.unpark(t1);
            LockSupport.unpark(t1);
            System.out.println(Thread.currentThread().getName() + " 发出通知");
        }, "t2").start();
    }
}

输出：

t2 come in
t2 发出通知
t1 come in
t1 通过第1个park

// 程序阻塞到这里

虚假唤醒

实现线程等待和唤醒时需要注意是否有虚假唤醒问题。

例如下面示例代码，本意是线程 A 和 线程 C 在 number 为 0 时对其加 1，线程 B 和线程 D 在 number 为 1 时对其减 1，最后结果预期是 0。

package juc;

/**
 * 虚假唤醒Demo
 */

class share {
    private int number = 0;

    public synchronized void increment() throws InterruptedException {
        if (number != 0) {
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName() + " : " + number);
        this.notifyAll();
    }

    public synchronized void decrement() throws InterruptedException {
        if (number == 0) {
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName() + " : " + number);
        this.notifyAll();
    }
}

public class SpuriousWakeupDemo {
    public static void main(String[] args) {
        share share = new share();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    share.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "A").start();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    share.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "B").start();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    share.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "C").start();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    share.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "D").start();
    }
}

实际运行结果可能是：

A : 1
D : 0
C : 1
B : 0
C : 1
B : 0
C : 1
B : 0
C : 1
B : 0
C : 1
B : 0
C : 1
B : 0
C : 1
B : 0
C : 1
B : 0
C : 1
B : 0
C : 1
B : 0
D : -1
D : -2
D : -3
D : -4
D : -5
D : -6
D : -7
D : -8
D : -9
A : -8

// 程序还可能阻塞住

出现这个问题的原因就是虚假唤醒，上述代码运行情况可能是：

  1. 线程 A 先抢到锁，将 number 加 1 ，number 为 1，通知其它线程，第 1 次方法执行结束，释放锁（因为 synchronized 是加在方法上面的，方法执行完后释放锁）

  2. 线程 C 抢到锁，判断 if (number != 0) 不满足条件，调用 this.wait() 等待，释放锁；

  3. 线程 A 抢到锁，第 2 次执行方法，判断 if (number != 0) 不满足条件，调用 this.wait() 等待，释放锁；

  4. 线程 B 抢到锁，将 number 减 1， number 为 0，通知其它线程，第 1 次方法执行结束释放锁；

  5. 线程 A 抢到锁，收到线程 B 的通知结束等待，执行 wait 后面的代码将 number 加 1， number 为 1，通知其它线程，第 2 次方法执行结束，释放锁；

  6. 线程 C 抢到锁，收到线程 A 的通知结束等待，执行 wait 后面的代码将 number 加 1，number 为 2，通知其它线程，第 2 次方法执行结束，释放锁;

    … …

    这里就出现了 number 大于 1 的情况，虽然和上面输出结果不一样，但都是不符合预期的结果。

解决方法是将判断条件 if (number == 0) 改为 while (number == 0)：

package juc;

/**
 * 虚假唤醒Demo
 */

class share {
    private int number = 0;

    public synchronized void increment() throws InterruptedException {
        while (number != 0) {
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName() + " : " + number);
        this.notifyAll();
    }

    public synchronized void decrement() throws InterruptedException {
        while (number == 0) {
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName() + " : " + number);
        this.notifyAll();
    }
}

public class SpuriousWakeupDemo {
    public static void main(String[] args) {
        share share = new share();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    share.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "A").start();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    share.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "B").start();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    share.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "C").start();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    share.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "D").start();
    }
}

修改后的输出为：

A : 1
D : 0
C : 1
B : 0
C : 1
B : 0
C : 1
B : 0
C : 1
B : 0
C : 1
B : 0
C : 1
B : 0
C : 1
B : 0
C : 1
B : 0
C : 1
B : 0
C : 1
B : 0
A : 1
D : 0
A : 1
D : 0
A : 1
D : 0
A : 1
D : 0
A : 1
D : 0
A : 1
D : 0
A : 1
D : 0
A : 1
D : 0
A : 1
D : 0

Process finished with exit code 0

参考

  • 尚硅谷JUC并发编程： 第 50 - 55 节 (https://www.bilibili.com/video/BV1ar4y1x727?spm_id_from=333.788.videopod.episodes&vd_source=9266b9af652d5902d068c94b9d60116f&p=50)
  • 【尚硅谷】大厂必备技术之JUC并发编程：第10节（https://www.bilibili.com/video/BV1Kw411Z7dF?p=10&spm_id_from=333.788.videopod.episodes&vd_source=9266b9af652d5902d068c94b9d60116f）
种树人20240819
关注
Java 并发编程：多线程如何实现阻塞与唤醒
码农架构
12-16 379
线程的阻塞和唤醒在多线程并发过程中是一个关键点，当线程数量达到很大的数量级时，并发可能带来很多隐蔽的问题。如何正确暂停一个线程，暂停后又如何在一个要求的时间点恢复，这些都需要仔细考虑的细节。Java为我们提供了多种API来对线程进行阻塞和唤醒操作，比如suspend与resume、sleep、wait与notify以及park与unpark等等。  睡眠 控制线程阻塞与唤醒的最简单方式就是sleep了，Java通过sleep(n)方法能让线程进入到阻塞等待状态，直到休眠时间达到指定值后自动唤醒
Java 并发编程：Java 线程模型介绍及使用
最新发布
栗筝i的博客
08-01 377
Java 线程是指程序中可以独立执行的单个代码执行路径。Java 使用类和包来实现多线程编程。线程是并发编程的基础，可以提高应用程序的性能，特别是在处理 I/O 密集型或 CPU 密集型任务时。线程（Thread）：是一个独立的执行单元，可以与其他线程并发执行；进程（Process）：是一个正在执行的程序，每个进程至少包含一个线程（主线程）；多线程（Multithreading）：在同一进程内同时运行多个线程，以实现并发处理。
Java等待与唤醒机制的简单实现
WanAkiko.
10-26 195
采取等待与唤醒机制目的：避免多个线程操作同一份数据时造成共享变量的争夺。 创建设备类： package proConModel; /** * 设备类 * * @author WanAkiko * */ public class Machine { String deviceName; // 设备名称 String deviceType; // 设备型号 boolean flag = false; // 设备状态，是否可用 } 创建生产者类 package proConModel;
java 线程等待与唤醒
Code-lover's Learning Notes
08-09 1546
概要 本章，会对线程等待/唤醒方法进行介绍。涉及到的内容包括： 1. wait(), notify(), notifyAll()等方法介绍 2. wait()和notify() 3. wait(long timeout)和notify() 4. wait() 和 notifyAll() 5. 为什么notify(), wait()等函数定义在Object中，而不是Thread中
java线程技术6_线程的挂起和唤醒
daisyZH的专栏
01-16 1040
转自：http://blog.chinaunix.net/uid-122937-id-215913.html 1. 线程的挂起和唤醒       挂起实际上是让线程进入“非可执行”状态下，在这个状态下CPU不会分给线程时间片，进入这个状态可以用来暂停一个线程的运行；在线程挂起后，可以通过重新唤醒线程来使之恢复运行。 挂起的原因可能是如下几种情况：      （1）通过调用sleep()
Java线程等待和唤醒
笑一个吧
09-18 377
锁对象 调用wait方法使线程等待 调用notify方法唤醒进程 注： 两证方法只能使用锁对象调用 package demo3_WaitAndNotify; //顾客和老板线程必须使用同步代码块包裹起来 保证线程和唤醒只能有一个在执行 //同步使用的锁对象必须保证唯一 //只有锁对象才能调用wait和 notify方法 public class demo01_WN { public static void main(String[] args) { Object obj=ne
Java线程的等待与唤醒
持续学习，共同进步
12-23 797
生产者和消费者必须使用同步代码块包裹起来，保证等待和唤醒只能有一个执行，同步使用的锁对象必须保证唯一 Thread中重要方法 void wait() 在其他线程调用此对象的notify（）方法或notifyall（）方法前，导致当前线程等待 void notify() 唤醒在此对象监视器上等待的单个线程后，会继续执行wait方法之后的代码 void notifyAll() 唤醒...
Java并发编程线程间通讯实现过程详解
08-19
Java并发编程线程间通讯实现过程详解是Java编程中非常重要的一部分，涉及到多线程之间的数据共享、同步和通信。在Java中，线程间通讯可以通过多种方式实现，本文将通过示例代码详细介绍一些常用的线程间通讯方式。 ...
Java并发编程学习笔记
04-11
Java并发编程是Java开发中必不可少的一部分，涉及到多线程、同步机制、线程池以及并发工具类等多个核心知识点。以下是对这些主题的详细说明： 1. **线程安全与锁 Synchronized 底层实现原理**： 线程安全是指在多...
Java并发编程示例(二)：获取和设置线程信息
09-04
在Java并发编程中，理解和掌握如何获取及设置线程信息对于优化多线程应用程序至关重要。本文将深入探讨`Thread`类中的关键属性，以及如何通过这些属性来监控和管理线程。 首先，每个线程都有一个唯一的标识，即`ID`...
java线程唤醒与等待_java - 线程等待与唤醒
weixin_39671621的博客
02-12 226
概要wait(), notify(), notifyAll()等方法介绍在Object.java中，定义了wait(), notify()和notifyAll()等接口。wait()的作用是让当前线程进入等待状态，同时，wait()也会让当前线程释放它所持有的锁。而notify()和notifyAll()的作用，则是唤醒当前对象上的等待线程；notify()是唤醒单个线程，而notifyAll()...
『Java练习生的自我修养』java-se进阶³ • 线程的等待与唤醒
Keep coding！
05-05 1533
实现线程间通信的方式之一，线程的等待与唤醒... ☕☕ Java进阶攻坚克难，持续更新，一网打尽IO、注解、多线程…等java-se进阶内容。
java让线程等待_Java多线程--让主线程等待所有子线程执行完毕
weixin_36364419的博客
02-22 151
主要方法public CountDownLatch(int count);public voidcountDown();public voidawait() throwsInterruptedException构造方法参数指定了计数的次数countDown方法，当前线程调用此方法，则计数减一awaint方法，调用此方法会一直阻塞当前线程，直到计时器的值为0例子Java代码 publicclass...
java线程的等待和唤醒
eleven的博客
12-26 1536
一.基础知识 java有一句话叫做一切皆对象，这个最基本的对象就是object；在object中，定义了几个和线程相关的方法，如下： notify() ：唤醒在此对象监视器上等待的单个线程。 notifyAll() ： 唤醒在此对象监视器上等待的所有线程。 wait()：让当前线程处于“等待(阻塞)状态”，“直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法”...
java线程等待的方法
w_yq111的博客
10-13 335
线程等待： Thread.sleep(10000); 交出线程占用CPU时间十秒钟. 单位是毫秒.
java多线程（七）线程等待与唤醒
maligebilaowang的博客
02-27 1010
在Object.java中，定义了wait(), notify()和notifyAll()等接口。wait()的作用是让当前线程进入等待状态，同时，wait()也会让当前线程释放它所持有的锁。而notify()和notifyAll()的作用，则是唤醒当前对象上的等待线程；notify()是唤醒单个线程，而notifyAll()是唤醒所有的线程。Object类中关于等待/唤醒的API详细信息如下：notify() – 唤醒在此对象监视器上等待的单个线程。
Java中的线程等待和唤醒
ConstXiong
09-28 1173
用死循环的方式，一直尝试获取锁。在任务耗时比较长或者并发冲突比较大的时候，就不适合。 因为任务耗时比较长或者并发冲突比较大的时候，可能要循环上万次都不止，才能获取到锁，太消耗 CPU 。 这种场景下，理想的解决方案： 线程执行任务的条件不满足时，阻塞自己，进入等待状态；当线程执行的任务条件满足时，通知等待的线程继续执行。 线程阻塞的方式，能够避免循环等待对 CPU 的消耗。 在...
java：线程的等待和唤醒
Mario_faker的博客
03-20 383
Java多线程中的wait与notify  在Java多线程编程中，wait()的作用的是让当前线程进入阻塞状态，notify()是让当前线程唤醒继续执行。虽然是对线程状态的控制，但它们其实都是Object中的方法，这是因为wait与notify所起的作用与线程间的对象锁有关。在执行wait()和notify()之前，必须要先获得对象锁，即一定要和synchronized一起使用。wait()的含...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值