并发编程之的虚假唤醒和精准唤醒的详细解析

简介: 并发编程之的虚假唤醒和精准唤醒的详细解析

虚假唤醒

例子

wait()是object类自带的方法,在jdk有介绍,有可能出现中断、虚假唤醒

也就是在下面的例子中

if(number != 0){
 this.wait();
}

当线程成功进入if语句块中,发生了中断,cpu跑去调度别的进程了,再次调度这个线程的时候,应该需要再经历一次if的判断,但是并没有这样做。

于是下面的程序运行结果:

/**
 * @author zkw
 * @Description TODO
 * 
 */
public class ThreadWaitNotify {
    public static void main(String[] args) {
        Resource resource = new Resource();
        //increment
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    resource.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A-1").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    resource.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A-2").start();
        //decrement
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    resource.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B-1").start();
        new Thread(()->{
            try {
                resource.decrement();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"B-2").start();
    }
}
class Resource{
    private int number = 0;
    //number++
    public synchronized void increment() throws InterruptedException {
        if(number != 0){
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName()+":"+number);
        this.notifyAll();
    }
    //number--
    public synchronized void decrement() throws InterruptedException {
        if(number == 0){
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+":"+number);
        this.notifyAll();
    }
}

解决办法

按照jdk文档的指示,应该将if换成while

   

  while(number == 0){
            this.wait();
        }

修改后,正确的运行结果如下:

精准唤醒

JUC那套 lock、await、signal和 Object那套 synchronized、wait、notify的区别:

condition这一套能实现精确唤醒某一个线程,而不是像notifyAll那样唤醒全部线程。

下面这个例子中,一共创建了三个Condition,可以根据业务对这三个Condition依次唤醒。来达到精准唤醒的功能

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
 * @author zkw
 * @Description 线程顺序访问
 *  多线程之间的顺序调用  A-》B-》C
 *  三个线程启动,要求如下:
 *  AA打印5次,BB打印10次,CC打印15次
 *  接着
 *  AA打印5次,BB打印10次,CC打印15次
 *  ....来10轮
 *
 *  1 高内聚低耦合的前提下,线程 操作 资源类
 *  2 判断/干活/通知
 *  3 多线程交互中,必须要防止多线程的虚假唤醒,也即(判断只用while不用if)
 *  4 标志位
 * 
 */
public class ThreadOrderAccess {
    public static void main(String[] args) {
        ShareResource shareResource = new ShareResource();
        new Thread(()->{
            try {
                for (int i = 0; i < 10; i++) {
                    shareResource.printf5();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"Thread1").start();
        new Thread(()->{
            try {
                for (int i = 0; i < 10; i++) {
                    shareResource.printf10();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"Thread2").start();
        new Thread(()->{
            try {
                for (int i = 0; i < 10; i++) {
                    shareResource.printf15();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"Thread3").start();
    }
}
class ShareResource{
    private int number = 1; //1:A    2:B    3C
    private Lock lock = new ReentrantLock();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();
    public void printf5() throws InterruptedException {
        lock.lock();
        try {
            while (number!=1){
                condition1.await();
            }
            for (int i = 0; i < 5; i++) {
                System.out.println(Thread.currentThread().getName()+"--AA");
            }
            number = 2;
            condition2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void printf10() throws InterruptedException {
        lock.lock();
        try {
            while (number!=2){
                condition2.await();
            }
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName()+"--BB");
            }
            number = 3;
            condition3.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void printf15() throws InterruptedException {
        lock.lock();
        try {
            while (number!=3){
                condition3.await();
            }
            for (int i = 0; i < 15; i++) {
                System.out.println(Thread.currentThread().getName()+"--CC");
            }
            number = 1;
            condition1.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

 


相关文章
|
11天前
|
人工智能 Go 调度
掌握Go并发:Go语言并发编程深度解析
掌握Go并发:Go语言并发编程深度解析
|
11天前
|
Java
并发编程之线程池的底层原理的详细解析
并发编程之线程池的底层原理的详细解析
54 0
|
11天前
|
Java
并发编程之线程池的应用以及一些小细节的详细解析
并发编程之线程池的应用以及一些小细节的详细解析
19 0
|
1天前
|
Java 开发者
探索Java并发编程:Fork/Join框架的深度解析
【5月更文挑战第25天】在多核处理器日益普及的今天,并发编程成为了提升应用性能的关键。Java语言提供了多种并发工具,其中Fork/Join框架是一个高效且强大的工具,用于处理分而治之的任务。本文将深入探讨Fork/Join框架的原理、使用及其在实际应用中的优化策略,旨在帮助开发者更好地利用这一框架以解决复杂的并发问题。
|
11天前
|
并行计算 数据处理 开发者
Python并发编程:解析异步IO与多线程
本文探讨了Python中的并发编程技术,着重比较了异步IO和多线程两种常见的并发模型。通过详细分析它们的特点、优劣势以及适用场景,帮助读者更好地理解并选择适合自己项目需求的并发编程方式。
|
11天前
|
存储 安全
【并发编程】深入解析CurrentHashmap
【并发编程】深入解析CurrentHashmap
6 0
|
11天前
|
存储 安全 Java
Java并发编程中的高效数据结构:ConcurrentHashMap解析
【4月更文挑战第25天】在多线程环境下,高效的数据访问和管理是至关重要的。Java提供了多种并发集合来处理这种情境,其中ConcurrentHashMap是最广泛使用的一个。本文将深入分析ConcurrentHashMap的内部工作原理、性能特点以及它如何在保证线程安全的同时提供高并发性,最后将展示其在实际开发中的应用示例。
|
2天前
|
移动开发 网络协议 安全
HTML5页面被运营商DNS问题及解决方案,app中h5页面源码的获取
HTML5页面被运营商DNS问题及解决方案,app中h5页面源码的获取
12 4
|
2天前
|
域名解析 网络协议 应用服务中间件
2024最新彩虹聚合DNS管理系统源码v1.3 全开源
聚合DNS管理系统可以实现在一个网站内管理多个平台的域名解析,目前已支持的域名平台有:阿里云、腾讯云、华为云、西部数码、DNSLA、CloudFlare。 本系统支持多用户,每个用户可分配不同的域名解析权限;支持API接口,支持获取域名独立DNS控制面板登录链接,方便各种IDC系统对接。
7 0
|
9天前
|
Linux 网络安全 Windows
网络安全笔记-day8,DHCP部署_dhcp搭建部署,源码解析
网络安全笔记-day8,DHCP部署_dhcp搭建部署,源码解析

推荐镜像

更多