synchronized 的虚假唤醒问题

最新推荐文章于 2023-02-17 20:19:46 发布
最新推荐文章于 2023-02-17 20:19:46 发布
阅读量293 收藏
点赞数 1
文章标签： java 多线程 sync 并发编程 多进程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42388853/article/details/111679873
版权

虚假唤醒：线程也可以唤醒，而不会被通知，中断或超时，即所谓的虚假唤醒 。 虽然这在实践中很少会发生，但应用程序必须通过测试应该使线程被唤醒的条件来防范，并且如果条件不满足则继续等待。（当线程只有一个消费者和一个生产者的时候不会发生，多个生产者和多个消费者同时进行if判断时才会发生）

举个简单例子，我们正常的生产者和消费者问题应该是：


//线程之间的通信问题:生产者和消费者问题!等待唤醒，通知唤醒线程交替执行A B操作同一个变量num = 0
//        A  num+1
//        B  num-1
public class A {
    public static void main(String[] args) {
    Data data=new Data();

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


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


    }
}

class Data{
    private int num=0;
    public synchronized void product() throws InterruptedException {
        if (num != 0) {
            wait();
        }
        num++;
        System.out.println(Thread.currentThread()+"线程生产了1份,当前:"+num);
        notifyAll();
    }

    public synchronized void consumer() throws InterruptedException {
        if (num == 0) {
            wait();
        }
        num--;
        System.out.println(Thread.currentThread()+"线程消费了1份,当前:"+num);
        notifyAll();
    }


}

然后结果是这样的：

Thread[A,5,main]线程生产了1份,当前:1
Thread[B,5,main]线程消费了1份,当前:0
Thread[A,5,main]线程生产了1份,当前:1
Thread[B,5,main]线程消费了1份,当前:0
Thread[A,5,main]线程生产了1份,当前:1
Thread[B,5,main]线程消费了1份,当前:0
Thread[A,5,main]线程生产了1份,当前:1
Thread[B,5,main]线程消费了1份,当前:0
Thread[A,5,main]线程生产了1份,当前:1
Thread[B,5,main]线程消费了1份,当前:0
Thread[A,5,main]线程生产了1份,当前:1
Thread[B,5,main]线程消费了1份,当前:0
Thread[A,5,main]线程生产了1份,当前:1

但是我们这里采用的是if来判断条件这时候会存在虚假唤醒，由于上面的例子只有一个生产者一个消费者所以没问题，下面演示多个的情况：


//线程之间的通信问题:生产者和消费者问题!等待唤醒，通知唤醒线程交替执行A B操作同一个变量num = 0
//        A  num+1
//        B  num-1
public class A {
    public static void main(String[] args) {
    Data data=new Data();

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


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


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


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

    }
}

class Data{
    private int num=0;
    public synchronized void product() throws InterruptedException {
        if (num != 0) {
            wait();
        }
        num++;
        System.out.println(Thread.currentThread()+"线程生产了1份,当前:"+num);
        notifyAll();
    }

    public synchronized void consumer() throws InterruptedException {
        if (num == 0) {
            wait();
        }
        num--;
        System.out.println(Thread.currentThread()+"线程消费了1份,当前:"+num);
        notifyAll();
    }


}

此时会出现结果：

Thread[B,5,main]线程消费了1份,当前:0
Thread[A,5,main]线程生产了1份,当前:1
Thread[C,5,main]线程生产了1份,当前:2
Thread[A,5,main]线程生产了1份,当前:3
Thread[B,5,main]线程消费了1份,当前:2
Thread[B,5,main]线程消费了1份,当前:1
Thread[B,5,main]线程消费了1份,当前:0
Thread[A,5,main]线程生产了1份,当前:1
Thread[C,5,main]线程生产了1份,当前:2
Thread[A,5,main]线程生产了1份,当前:3
Thread[B,5,main]线程消费了1份,当前:2
Thread[B,5,main]线程消费了1份,当前:1
Thread[A,5,main]线程生产了1份,当前:2
Thread[C,5,main]线程生产了1份,当前:3
Thread[A,5,main]线程生产了1份,当前:4

那么怎么处理虚假唤醒这个问题呢？翻阅jdk的api发现：在这里插入图片描述

 换句话说，等待应该总是出现在循环中，就像这样： 

  synchronized (obj) {
         while (<condition does not hold>)
             obj.wait(timeout);
         ... // Perform action appropriate to condition
     }

我们将if改为while在尝试一次：


//线程之间的通信问题:生产者和消费者问题!等待唤醒，通知唤醒线程交替执行A B操作同一个变量num = 0
//        A  num+1
//        B  num-1
public class A {
    public static void main(String[] args) {
    Data data=new Data();

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


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


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


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

    }
}

class Data{
    private int num=0;
    public synchronized void product() throws InterruptedException {
        while (num != 0) {
            wait();
        }
        num++;
        System.out.println(Thread.currentThread()+"线程生产了1份,当前:"+num);
        notifyAll();
    }

    public synchronized void consumer() throws InterruptedException {
        while (num == 0) {
            wait();
        }
        num--;
        System.out.println(Thread.currentThread()+"线程消费了1份,当前:"+num);
        notifyAll();
    }


}

虚假唤醒问题被解决了：

Thread[B,5,main]线程消费了1份,当前:0
Thread[C,5,main]线程生产了1份,当前:1
Thread[B,5,main]线程消费了1份,当前:0
Thread[A,5,main]线程生产了1份,当前:1
Thread[B,5,main]线程消费了1份,当前:0
Thread[C,5,main]线程生产了1份,当前:1
Thread[B,5,main]线程消费了1份,当前:0
Thread[A,5,main]线程生产了1份,当前:1
Thread[B,5,main]线程消费了1份,当前:0
Thread[C,5,main]线程生产了1份,当前:1
Thread[B,5,main]线程消费了1份,当前:0
Thread[A,5,main]线程生产了1份,当前:1
Thread[B,5,main]线程消费了1份,当前:0
Thread[C,5,main]线程生产了1份,当前:1
Thread[B,5,main]线程消费了1份,当前:0
Thread[A,5,main]线程生产了1份,当前:1
Thread[B,5,main]线程消费了1份,当前:0
Thread[C,5,main]线程生产了1份,当前:1
Thread[B,5,main]线程消费了1份,当前:0

为什么会出现这样的结果，我们拿消费者来举例，假如存在虚假唤醒，那么此时的num==0，就进入等待，一直等到num不是虚假唤醒而是真实唤醒num变成了1

结论：判断用while别用if

年轻的猴
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Qt 线程池
weixin_46870692的博客
10-24 566
Qt 线程池
python线程start_Python线程类| start（）方法与示例
cumubi7552的博客
07-16 5023
python线程start Python Thread.start()方法 (Python Thread.start() Method) Thread.start() method is an inbuilt method of the Thread class of the threading module in Python. It is used to start a thread's ac...
线程池的使用步骤
weixin_49578980的博客
09-17 2740
线程池的使用步骤 使用线程池的工厂类Executors里面提供的静态方法newFixedThreadPool生产一个指定线程数量的线程池 创建一个类,实现Runnable接口,重写run方法,设置线程任务 调用ExecutorService中的方法submit,传递线程任务(实现类),开启线程,执行run方法 调用ExecutorService中的方法shutdown销毁线程池(不建议执行) public class ThreadPool{ public static void main(Str
你的ThreadLocal线程安全么
weixin_30784945的博客
05-24 480
想必很多小伙伴们对ThreadLocal并不陌生，ThreadLocal叫做线程本地变量，也就是ThreadLocal为变量在每个线程中都创建了一个副本，每个线程可以访问自己内部的副本变量。那么，我们使用ThreadLocal一定线程安全么？话不多说，先上结论： 如果threadlocal.get之后的副本，只在当前线程中使用，那么是线程安全的；如果对其他线程暴露，不一定是线程安全...
python thread start_Python多线程-thread.start_new_thread简单使用
weixin_39571749的博客
12-21 1361
在使用python多线程的时候，踩到了主线程未等待多线程进程运行完成就结束，导致多线程无效的坑。后来想到自己写个全局变量监控多线程是否全部完成。话不多说，上代码。def test(i):global unfinished_threadprint '开始运行第%s个进程'%itime.sleep(i)lock.acquire()unfinished_thread -= 1print '结束运行第%s...
【原创】读写锁ReentrantReadWriteLock原理分析(一)
weixin_33750452的博客
02-25 96
Java里面真正意义的锁并不多，其实真正的实现Lock接口的类就三个，ReentrantLock和ReentrantReadWriteLock的两个内部类（ReentrantReadWriteLock实现了ReadWriteLock接口，并没有实现Lock接口，是其内部类ReadLock和WriteLock实现了Lock的接口），其他都是通过我们前面说的一些工具类实现了线程的阻塞。 ...
Python—MySQL线程池
weixin_30454481的博客
01-11 839
python实现版本：#!/usr/python/bin/python3 # -*- coding:utf-8 -*- ############################ #File Name: mysql_threading_pool.py #Author: ykyk #Mail: 525178992@qq.com #Created Time: 2019-01-10 09:17:32 ##...
python thread start_python线程之start_new_thread - ksnowlv
weixin_39834205的博客
12-21 754
Python中使用线程有两种方式：1.函数式方式2.类包装线程对象方式。下面使用函数式方式，调用thread模块中的start_new_thread()函数来产生新线程。语法格式如下:thread.start_new_thread ( function, args[, kwargs] )代码示例如下:#!/usr/bin/pythonimport threadimport time#为线程定义一个...
python多线程中锁的概念
weixin_34242509的博客
03-29 439
python的锁可以独立提取出来 mutex = threading.Lock() #锁的使用 #创建锁 mutex = threading.Lock() #锁定 mutex.acquire([timeout]) #释放 mutex.release() 概念 好几个人问我给资源加锁是怎么回事，其实并不是给资源加锁, 而是用锁去锁定资源，你可以定义多个锁, 像下...
Python threading中lock的使用
热门推荐
锅炉房刘大爷的博客
03-28 3万+
在多线程中使用lock可以让多个线程在共享资源的时候不会“乱”，例如，创建多个线程，每个线程都往空列表l中添加一个数字并打印当前的列表l，如果不加锁，就可能会这样：# encoding=utf8 import threading import time lock = threading.Lock() l = [] def test1(n): lock.acquire() l.append...
ReentrantReadWriteLock原理
crazy_lala的博客
12-05 405
读写锁：ReentrantReadWriteLock 当读操作远远高于写操作时，这时候使用 读写锁 让 读-读 可以并发，提高性能。类似于数据库中select … from … lock in share mode。 使用举例： package com.concurrent.test; import java.util.concurrent.locks.ReentrantReadWriteLock; public class TestReadWriteLock { public static
QT-线程池
最爱吹吹风
04-19 8480
在程序逻辑中经常会碰到需要处理大批量任务的情况，比如密集的网络请求，或者日志分析等等。一般会创建一个队列，用一个或者多个线程去消费这个队列，一般也要处理队列的加锁和解锁的问题，除非在设计时就能够做到专列专用，否则锁是不可避免的。而且在入队和出队的操作上肯定还是要加锁，因为他们是在不同线程对同一个资源进行操作。 线程池就是为这个而设计的，比如 Wi...
Qt线程池
weixin_45001971的博客
02-17 5764
Qt线程池
Qt 线程池
Skynet的博客
08-01 1361
继承QRunnable的类，QRunnable为虚基类，需要重写run函数 threadtask.h 单个任务类声明文件 #ifndef THREADTASK_H #define THREADTASK_H #include <QRunnable> class ThreadTask : public QRunnable { public: ThreadTask(int...
ThreadLocal 是线程安全吗
夏天吹雪的博客
05-17 2627
threadLocal 不能保证线程安全，因为如果是同一对象锁，存在堆中， 有可能指向同一对象，多个线程修改同一对象，导致线程不安全。 除非加锁的对象不是同一个，不同对象存在于不同线程副本中，则可以线程安全。 sync加锁的概念底层是Monitor 监控器 ...
python thread start_Python线程.thread.start（）未将控制权返回主线程
weixin_39638105的博客
12-21 257
Thread.start() never returns! Could this have something to do with the C implementation of the math library?注意：multiprocessing版本应该按原样工作：每个Python进程都有自己的GIL。在factorial(1000000000)有数亿个数字。{asdummy}取而代之的是计...
java多线程中何为虚假唤醒？如何避免虚假唤醒？
最新发布
11-09
虚假唤醒通常是由于线程竞争条件的存在而引起的。 为了避免虚假唤醒，可以在while循环中使用wait()方法，而不是if语句。这样，当线程被唤醒时，它会再次检查条件是否满足，如果不满足，它会继续等待。另外，可以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值