线程同步的一些思考(二) 虚假唤醒的解决

最新推荐文章于 2025-06-07 13:26:29 发布
最新推荐文章于 2025-06-07 13:26:29 发布
阅读量458 收藏 1
点赞数
CC 4.0 BY-SA版权
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_43230007/article/details/131581036
文章讨论了Java中线程同步的重要性和虚假唤醒的问题，提出使用while循环代替if判断以避免虚假唤醒。同时，介绍了使用ReentrantLock、volatile、CountDownLatch、CyclicBarrier、Semaphore和Exchanger等不同方式实现线程同步和交替执行的示例。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

线程同步的一些思考(二) 虚假唤醒的解决

说明

在之前**线程同步的一些思考(一)**中，其实有一些可以优化的地方，就是if的判断可以改成while

为什么呢，因为虚假唤醒情况的存在

代码示例如下：



public class PrintUtil {

  private static final Object lock = new Object();
  private static boolean isPrintA = false;

  public static void main(String[] args) throws InterruptedException {
    Thread threadA = new Thread(new PrintA());
    Thread threadB = new Thread(new PrintB());

//    extractedA(threadA, threadB);
    extractedB(threadA, threadB);
  }

  private static void extractedA(Thread threadA, Thread threadB) throws InterruptedException {
    threadA.start();
    Thread.sleep(1000);
    threadB.start();
  }
  private static void extractedB(Thread threadA, Thread threadB) throws InterruptedException {
    threadB.start();
    Thread.sleep(1000);
    threadA.start();
  }

  static class PrintA implements Runnable {

    @Override
    public void run() {
      for (int i = 0; i < 10; i++) {
        synchronized (lock) {
          while (isPrintA) {
            try {
              lock.wait();
            } catch (InterruptedException e) {
              e.printStackTrace();
            }
          }
          System.out.println("A");
          isPrintA = true;
          lock.notify();
        }
      }
    }
  }

  static class PrintB implements Runnable {

    @Override
    public void run() {
      for (int i = 0; i < 10; i++) {
        synchronized (lock) {
          while (!isPrintA) {
            try {
              lock.wait();
            } catch (InterruptedException e) {
              e.printStackTrace();
            }
          }
          System.out.println("B");
          isPrintA = false;
          lock.notify();
        }
      }
    }
  }
}

什么是虚假唤醒

虚假唤醒（Spurious Wakeup）是指一个线程在没有收到显式的唤醒信号的情况下，从等待状态中被唤醒。虽然虚假唤醒的发生机制可能因操作系统和具体实现而异，但一般是由于系统或实现的内部原因导致的。

虚假唤醒的发生原理是多方面的，包括操作系统、编译器优化、硬件等。下面是一些可能导致虚假唤醒的原因：

  1. 系统或实现内部的信号丢失：在某些情况下，操作系统或实现内部可能存在信号丢失的问题，导致线程在没有显式唤醒的情况下被唤醒。

  2. 硬件中断：在某些平台和硬件架构中，硬件中断可能会导致线程的唤醒，而这些中断可能与条件变量的状态无关。

  3. JVM 优化：JVM 可能会对等待线程进行一些优化，例如对等待线程进行批处理或重排序。这些优化可能会导致线程在没有显式唤醒的情况下被唤醒。

虚假唤醒的场景并不常见，但以下是一个简单的示例来说明虚假唤醒的可能性：

public class SpuriousWakeUpExample {
    private static final Object lock = new Object();
    private static boolean condition = false;

    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(new WaitThread());
        Thread thread2 = new Thread(new NotifyThread());

        thread1.start();
        Thread.sleep(1000);
        thread2.start();
    }

    static class WaitThread implements Runnable {
        @Override
        public void run() {
            synchronized (lock) {
                while (!condition) {
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("Condition is true");
            }
        }
    }

    static class NotifyThread implements Runnable {
        @Override
        public void run() {
            synchronized (lock) {
                condition = true;
                lock.notify();
            }
        }
    }
}

在上述示例中，WaitThread 线程等待条件变量 condition 为 true，而 NotifyThread 线程负责将 condition 设置为 true 并调用 notify() 方法。

尽管看起如此，WaitThread 在条件不满足时进入等待状态，并在被 NotifyThread 唤醒后打印消息。然而，由于可能存在虚假唤醒，WaitThread 有时可能会在条件不满足的情况下被唤醒，导致消息的打印是不准确的。

虚假唤醒的发生是由于操作系统或 JVM 内部的实现细节造成的，具体的场景和原因可能因不同的系统和环境而异。尽管虚假唤醒是可能的，但它在实践中相对较少发生，特别是在合理使用条件变量并采用正确的同步机制的情况下。

为了防止虚假唤醒，常见的做法是在等待状态下使用 while 循环进行条件检查，而不是使用 if 语句。这样可以确保在唤醒后再次检查条件，以避免虚假唤醒所带来的问题。

需要注意的是，在使用 wait()、notify() 和 notifyAll() 方法时，必须在 synchronized 块中进行调用，并且只能在持有同一个对象的锁的线程之间进行通信。

其它线程同步方式的实现

ReentrantLock


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

public class PrintUtil {
  private static ReentrantLock lock = new ReentrantLock();
  private static boolean isPrintA = true;
  private static Condition condition = lock.newCondition();

  public static void main(String[] args) throws InterruptedException {
    Thread threadA = new Thread(new PrintA());
    Thread threadB = new Thread(new PrintB());

    threadB.start();
    Thread.sleep(1000);
    threadA.start();
  }

  static class PrintA implements Runnable {
    @Override
    public void run() {
      for (int i = 0; i < 10; i++) {
        lock.lock();
        try {
          while (!isPrintA) {
            condition.await();
          }
          System.out.println("A");
          isPrintA = false;
          condition.signal();
        } catch (InterruptedException e) {
          e.printStackTrace();
        } finally {
          lock.unlock();
        }
      }
    }
  }

  static class PrintB implements Runnable {
    @Override
    public void run() {
      for (int i = 0; i < 10; i++) {
        lock.lock();
        try {
          while (isPrintA) {
            condition.await();
          }
          System.out.println("B");
          isPrintA = true;
          condition.signal();
        } catch (InterruptedException e) {
          e.printStackTrace();
        } finally {
          lock.unlock();
        }
      }
    }
  }
}
volatile

Atomics原子类也是类似，不进行补充了

Thread.yield() 是一个静态方法，它的作用是告诉线程调度器当前线程愿意放弃当前的 CPU 时间片，让其他具有相同优先级的线程有机会运行。调用 Thread.yield() 方法并不会阻塞当前线程，而是使当前线程从运行状态转换为可运行状态，然后等待线程调度器重新选择执行哪个线程

public class PrintUtil {
    private static volatile boolean isPrintA = true;

    public static void main(String[] args) throws InterruptedException {
        Thread threadA = new Thread(new PrintA());
        Thread threadB = new Thread(new PrintB());

        threadB.start();
        Thread.sleep(1000);
        threadA.start();
    }

    static class PrintA implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                while (!isPrintA) {
                    Thread.yield();
                }
                System.out.println("A");
                isPrintA = false;
            }
        }
    }

    static class PrintB implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                while (isPrintA) {
                    Thread.yield();
                }
                System.out.println("B");
                isPrintA = true;
            }
        }
    }
}
CountDownLatch
import java.util.concurrent.CountDownLatch;

public class PrintUtil {
    private static CountDownLatch latchA = new CountDownLatch(1);
    private static CountDownLatch latchB = new CountDownLatch(1);

    public static void main(String[] args) throws InterruptedException {
        Thread threadA = new Thread(new PrintA());
        Thread threadB = new Thread(new PrintB());

        threadA.start();
        threadB.start();

        // 通过释放第一个 latch，使 PrintA 线程先执行
        latchA.countDown();
        threadA.join();
        threadB.join();
    }

    static class PrintA implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                try {
                    latchA.await(); // 等待 latchA 释放
                    System.out.println("A");
                    latchA = new CountDownLatch(1); // 重置 latchA
                    latchB.countDown(); // 通知 PrintB 线程可以执行
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    static class PrintB implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                try {
                    latchB.await(); // 等待 latchB 释放
                    System.out.println("B");
                    latchB = new CountDownLatch(1); // 重置 latchB
                    latchA.countDown(); // 通知 PrintA 线程可以执行
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

在上述示例中，我们使用两个 CountDownLatch 对象 latchA 和 latchB 来控制线程的执行顺序。PrintA 线程负责打印 “A”，在每次打印完成后释放 latchA，然后等待 latchB 的释放。PrintB 线程负责打印 “B”，在每次打印完成后释放 latchB，然后等待 latchA 的释放。

通过适当的释放和等待 CountDownLatch，可以实现线程的交替打印。在 main 方法中，我们先释放 latchA，使 PrintA 线程先执行，然后通过 join() 方法等待两个线程执行完毕。

CyclicBarrier
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class PrintUtil {
    private static CyclicBarrier barrier = new CyclicBarrier(2);

    public static void main(String[] args) throws InterruptedException {
        Thread threadA = new Thread(new PrintA());
        Thread threadB = new Thread(new PrintB());

        threadA.start();
        threadB.start();

        threadA.join();
        threadB.join();
    }

    static class PrintA implements Runnable {
        @Override
        public void run() {
            try {
                for (int i = 0; i < 10; i++) {
                    System.out.println("A");
                    barrier.await(); // 等待其他线程到达栅栏
                    barrier.reset(); // 重置栅栏
                }
            } catch (InterruptedException | BrokenBarrierException e) {
                e.printStackTrace();
            }
        }
    }

    static class PrintB implements Runnable {
        @Override
        public void run() {
            try {
                for (int i = 0; i < 10; i++) {
                    barrier.await(); // 等待其他线程到达栅栏
                    System.out.println("B");
                    barrier.reset(); // 重置栅栏
                }
            } catch (InterruptedException | BrokenBarrierException e) {
                e.printStackTrace();
            }
        }
    }
}

在上述示例中，我们创建了一个 CyclicBarrier 对象 barrier，并将参与的线程数设置为 2。PrintA 和 PrintB 线程分别负责打印 “A” 和 “B”，在每次打印完成后调用 barrier.await() 方法等待其他线程到达栅栏。当所有线程都到达栅栏后，它们会被释放并继续执行，然后重置栅栏。

在 main 方法中，我们启动两个线程并等待它们执行完毕。

需要注意的是，CyclicBarrier 是可重用的栅栏，每次到达栅栏的线程都会被释放并继续执行，而栅栏的初始状态是由参与的线程数确定的。因此，在每次打印完成后，我们需要显式地调用 barrier.reset() 方法来重置栅栏，以便下一轮的交替打印。

使用 CyclicBarrier 可以实现线程的有序执行和同步，确保线程按照指定的顺序交替执行。

Semaphore
import java.util.concurrent.Semaphore;

public class PrintUtil {
    private static Semaphore semaphoreA = new Semaphore(1);
    private static Semaphore semaphoreB = new Semaphore(0);

    public static void main(String[] args) throws InterruptedException {
        Thread threadA = new Thread(new PrintA());
        Thread threadB = new Thread(new PrintB());

        threadA.start();
        threadB.start();

        threadA.join();
        threadB.join();
    }

    static class PrintA implements Runnable {
        @Override
        public void run() {
            try {
                for (int i = 0; i < 10; i++) {
                    semaphoreA.acquire(); // 获取 semaphoreA 的许可
                    System.out.println("A");
                    semaphoreB.release(); // 释放 semaphoreB 的许可
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    static class PrintB implements Runnable {
        @Override
        public void run() {
            try {
                for (int i = 0; i < 10; i++) {
                    semaphoreB.acquire(); // 获取 semaphoreB 的许可
                    System.out.println("B");
                    semaphoreA.release(); // 释放 semaphoreA 的许可
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

在上述示例中，我们创建了两个 Semaphore 对象 semaphoreA 和 semaphoreB，并初始化它们的许可数。PrintA 线程负责打印 “A”，在每次打印完成后调用 semaphoreB.release() 方法释放 semaphoreB 的许可，然后等待 semaphoreA 的许可。PrintB 线程负责打印 “B”，在每次打印完成后调用 semaphoreA.release() 方法释放 semaphoreA 的许可，然后等待 semaphoreB 的许可。

通过适当的获取和释放 Semaphore 的许可，可以实现线程的交替打印。在 main 方法中，我们启动两个线程并等待它们执行完毕。

使用 Semaphore 可以控制线程的并发数量，实现线程间的同步和协调。在本例中，semaphoreA 和 semaphoreB 的许可数都是 1，保证了线程的交替执行。

Exchanger
import java.util.concurrent.Exchanger;

public class PrintUtil {
    private static Exchanger<Boolean> exchanger = new Exchanger<>();

    public static void main(String[] args) throws InterruptedException {
        Thread threadA = new Thread(new PrintA());
        Thread threadB = new Thread(new PrintB());

        threadA.start();
        threadB.start();

        threadA.join();
        threadB.join();
    }

    static class PrintA implements Runnable {
        @Override
        public void run() {
            try {
                for (int i = 0; i < 10; i++) {
                    System.out.println("A");
                    exchanger.exchange(true); // 交换数据并等待对方线程打印
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    static class PrintB implements Runnable {
        @Override
        public void run() {
            try {
                for (int i = 0; i < 10; i++) {
                    exchanger.exchange(false); // 交换数据并等待对方线程打印
                    System.out.println("B");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

在上述示例中，我们创建了一个 Exchanger 对象 exchanger，用于交换线程的打印信号。PrintA 线程负责打印 “A”，在每次打印完成后调用 exchanger.exchange(true) 方法与 PrintB 线程进行数据交换，并等待 PrintB 线程打印。PrintB 线程负责打印 “B”，在每次打印完成后调用 exchanger.exchange(false) 方法与 PrintA 线程进行数据交换，并等待 PrintA 线程打印。

通过 Exchanger 的交换机制，可以实现线程的交替打印。在 main 方法中，我们启动两个线程并等待它们执行完毕。

需要注意的是，Exchanger 只能在两个线程之间进行数据交换，因此适用于交替执行的场景。如果有多个线程需要交替执行，可以结合使用 Exchanger 和其他同步工具来实现。

虚假唤醒详解
horacen的博客
04-28 7273
虚假唤醒详解        接触过多线程编程的朋友们或多或少都听说过虚假唤醒这一术语，我在百度上看了很多相关的帖子，说的都不是很清楚，于是写下这篇文章，希望能对大家有些裨益。 虚假唤醒是什么        首先我们来谈谈虚假唤醒到底是什么。在这里我给出一个自己的定义，帮助大家去理解虚假唤醒 虚假唤醒是一种现象，它只会出现在多线程环境中，指的是在多线程环境下，多个线程等
操作系统总结系列之【线程同步】
存星的博客
01-26 714
目录 1.线程同步 what why 举例 how 互斥量（互斥锁） 读写锁 条件变量 信号量（信号灯） 2.总结 几种线程同步方式的总结： 本文针对linux系统的线程同步机制做出总结，如有理解错误之处或需要优化的地方望请指出，感谢。 1.线程同步 what 多线程通过特定的方式来控制线程之间执行的顺序。 why 产生原因：多线程访问共享数据时，可能发生冲突。 举例 两个线程操作同一个变量，分为三个步骤：从内存读变量到寄存器、寄存器中赋值、将寄存器值写回内
线程同步中的虚假唤醒
qq_36087425的博客
04-24 248
在多核处理器下pthread_cond_signal可能唤醒多于一个线程（阻塞在条件变量上的线程）。 结果是，当一个线程调用pthread_cond_signal()后，多个调用pthread_cond_wait()或pthread_cond_timedwait()线程返回。这就叫虚假唤醒 解决办法：将判断条件改成while void* printA(void *arg) { while(1) ...
虚假唤醒以及解决
qq_47711757的博客
07-29 384
虚拟唤醒问题，lock解决
线程虚假唤醒情况介绍
https://vinfai.github.io/
06-13 130
    虚假唤醒的原因：  http://blog.youkuaiyun.com/nhn_devlab/article/details/6117239 http://en.wikipedia.org/wiki/Spurious_wakeup http://www.cnblogs.com/leaven/archive/2010/06/03/1750973.html ...
线程虚假唤醒
qq_39306234的博客
11-25 222
当判断是IF时 判断成功后就可能会唤醒其他线程，这就是虚假唤醒，所以要把if 改成 while 来防止
Java Condition：解决线程死锁问题的有效手段
最新发布
Java大师兄的博客
06-07 545
在 Java 多线程编程中，线程死锁是一个常见且棘手的问题。当多个线程相互等待对方释放资源时，就可能陷入死锁状态，导致程序无法正常运行。Java Condition 提供了一种有效的解决方案，本博客的目的就是深入介绍 Java Condition 如何解决线程死锁问题，范围涵盖了 Java Condition 的原理、使用方法、实际应用等方面。本文首先会介绍相关的术语和概念，为理解 Java Condition 打下基础。
怎么查看boost::condition notify_all 唤醒的线程是否存在
02-18
用户可能是在使用Boost线程库时遇到了多线程同步的问题，特别是当调用notify_all后，不确定是否有线程被正确唤醒。所以他们的需求可能是想验证线程是否真的被唤醒，或者在调试时确认通知是否有效。 首先，我得回忆...
JAVA如何在线程中加锁（四种方法）
热门推荐
weixin_43907440的博客
04-22 3万+
JAVA多线程锁 线程的生命周期 ​ 总共六种状态，可归结为五种，线程的最终是死亡，阻塞不是最终状态，只是一个临时状态。只有调用了start方法，线程才进入就绪阶段。 //新生 ​ NEW, //运行​ RUNNABLE, //阻塞​ BLOCKED, //等待，死死地等​ WAITING, //超时等待​ TIMED_WAITING, //终止​ ...
C语言多线程设计模式：生产者-消费者问题的完美解决方案
![C语言多线程设计模式：生产者-消费者问题...在C语言中实现多线程，通常依赖于POSIX线程库（pthread），它提供了创建、控制线程以及实现线程间同步与互斥等核心功能。理解C语言多线程的基础概念和原理，是掌握更深层次
线程的虚假唤醒
cristianoxm的博客
04-14 231
//真正唤醒 while (!cond) { lock.wait(); } //虚假唤醒 if(!code) { lock.wait(); } 在不同的语言，甚至不同的操作系统上，条件锁都会产生虚假唤醒现象。所有语言的条件锁库都推荐用户把wait()放进循环里： 我们知道wait()状态的时候，线程会释放资源，等到被唤醒的时候，从上次wait()的地方醒来，继续执行，如果使用条件判断，判...
线程中的虚假唤醒
qq_62984376的博客
08-27 1053
因为if只进行一次判断，假设当+1抢到了资源， 此时的num=1，其他三个线程进行资源抢夺，即使此时+1*抢到了资源，但是判断后，无法进行下面的代码，就沉睡下去，再当+1抢到资源时，就不会再从开始进行if判断了，从而会直接执行下面的++代码，使得num的值变为了2，导致线程不安全的情况，造成了虚假唤醒。扩容时，容量同样会增加为原来的1.5倍，并且所有键值对会重新哈希到新的位置上。中断和虚假唤醒是可能产生的，所以要用loop循环，if只判断一次，while是只要唤醒就要拉回来再判断一次。
关于线程的虚假唤醒
苏州-青蛙
06-08 191
最近用c++标准库写生产者消费者模式的线程操作队列，对一些代码感到疑惑。比如下面这个线程函数 中为什么要用 while (m_strSendBuf.empty()) 不直接用if判断，百度了一下果然这里存在一个比较常见的线程问题-虚假唤醒。 void ClientSocketManager::SendThreadProc() { while (!m_bStop) { std::unique_lock<std::mutex> guard(m_mtSendBuf...
Java多线程中的虚假唤醒和如何避免
随机的未知——用已知去面对未知
12-03 518
先来看一个例子 一个卖面的面馆，有一个做面的厨师和一个吃面的食客，需要保证，厨师做一碗面，食客吃一碗面，不能一次性多做几碗面，更不能没有面的时候吃面；按照上述操作，进行十轮做面吃面的操作。 用代码说话 首先我们需要有一个资源类，里面包含面的数量，做面操作，吃面操作； 当面的数量为0时，厨师才做面，做完面，需要唤醒等待的食客，否则厨师需要等待食客吃完面才能做面； 当面的数量不为0时，食客才能吃面，吃完面需要唤醒正在等待的厨师，否则食客需要等待厨师做完面才能吃面； 然后在主类中，我们创建一个厨师线程进行10次做
Java线程虚假唤醒
weixin_49050715的博客
07-13 458
文章目录什么是虚假唤醒为什么会出现虚假唤醒解决的方法 #什么是虚假唤醒 #为什么会出现虚假唤醒 #解决的方法 什么是虚假唤醒 如图，JavaJdk10API文档这样描述 意思就是说线程可以在没有被通知，中断或者超时的情况下被唤醒，这就是所谓的虚假唤醒 为什么会出现虚假唤醒 1.当Object.wait()这个方法运行时，当前的线程会进入等待状态，并自动释放锁。当被其他线程唤醒时，它会在wait()之后的地方继续开始运行 2.当Object.notifyAll运行时，会唤醒所有处于等待状态的线程同时进行抢
线程虚假唤醒问题
weixin_41677387的博客
02-28 383
转载： 1、什么是虚假唤醒？ 虚假唤醒就是在多线程执行过程中，线程间的通信未按照我们幻想的顺序唤醒，故出现数据不一致等不符合我们预期的结果。比如 我的想法是：加1和减1交替执行，他却出现了2甚至3这种数：请看下面例子： 假设有四个线程A、B、C、D同时启动，我们定义A和B为加法线程，C和D为减法线程，每个线程执行5次回到原点，我们的期望结果是：0，1，0，1，0，1…0，1，0 顺此进行，但执行结果却是： public class ThreadTest { public static voi
线程虚假唤醒，你搞明白了吗？
StoNENee的博客
04-06 360
线程虚假唤醒，你搞明白了吗？
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值