【问题标题】:Wait until boolean value changes it state等到布尔值改变它的状态
【发布时间】:2013-10-02 06:02:54
【问题描述】:

我有一个线程等待布尔值改变如下:

while(!value)
{
  Thread.sleep(1000)
}
// Do some work after change of the value

这不是我喜欢的方式,因为会消耗大量 CPU。

有什么办法可以阻塞线程,直到布尔值改变它的状态?

【问题讨论】:

    标签: java multithreading boolean


    【解决方案1】:

    这不是我喜欢的方式,因为会消耗大量 CPU。

    如果这实际上是您的工作代码,那么就保持这样。每秒检查一次布尔值会导致没有可测量的 CPU 负载。什么都没有。

    真正的问题是检查值的线程可能看不到由于缓存而在任意长时间内发生的更改。为保证值在线程间始终保持同步,需要在变量定义中放入 volatile 关键字,即

    private volatile boolean value;
    

    请注意,将访问权限放在synchronized 块中,例如在使用其他答案中描述的基于通知的解决方案时,将具有相同的效果。

    【讨论】:

      【解决方案2】:

      您需要一种避免忙等待的机制。旧的wait/notify 机制充满了陷阱,所以更喜欢java.util.concurrent 库中的一些东西,例如CountDownLatch:

      public final CountDownLatch latch = new CountDownLatch(1);
      
      public void run () {
        latch.await();
        ...
      }
      

      在另一边打电话

      yourRunnableObj.latch.countDown();
      

      但是,启动一个线程只等到需要它时什么都不做,这仍然不是最好的方法。您还可以使用ExecutorService,将满足条件时必须完成的工作作为任务提交给它。

      【讨论】:

      • 这有助于我在 JUnit 中测试 Quartz 库。 Quartz 在一个拥有自己线程池的黑盒中运行它的工作。我可以使用 Java 文档中指定的确切模式向 JUnit 发出信号以等待石英作业完成。
      • 我可以推荐Java.util.concurrent.BlockingQueue 及其各种实现吗? take() 和 offer() 方法是同步的一个很好的起点。
      【解决方案3】:

      wait-notify 怎么样

      private Boolean bool = true;
      private final Object lock = new Object();
      
      private Boolean getChange(){
        synchronized(lock){
          while (bool) {
            bool.wait();
          }
         }
        return bool;
      }
      public void setChange(){
         synchronized(lock){
             bool = false;
             bool.notify();
         }
      }
      

      【讨论】:

      • bool 是一个可变字段,您无法对其进行同步。
      • 嗯...这实际上是一个很好的观点@axtavt。
      • 现在您正在一个非最终字段上进行同步。在setChange 中,您将首先对其进行修改,然后通知新的false 实例。结果:在较早的true 实例上等待的线程永远不会得到通知。为什么要避免整个机制的另一个很好的例子。
      • 嗯...谢谢@MarkoTopolnik 我认为如果我创建显式锁定对象并使用它同步会更好。(final Object lock=new Object()),怎么样?
      • 您需要等待锁定,而不是 bool - 但在这种情况下使用简单的 CountDownLatch 似乎是更好的解决方案。
      【解决方案4】:

      好吧,也许这个应该可以解决您的问题。请注意,每次进行更改时,都会调用 change() 方法来释放等待。

      Integer any = new Integer(0);
      
      public synchronized boolean waitTillChange() {
          any.wait();
          return true;
      }
      
      public synchronized void change() {
          any.notify();
      }
      

      【讨论】:

      • 整数是不可变的,你不能改变它的值
      【解决方案5】:

      在这种情况下我更喜欢使用互斥机制,但如果你真的想使用布尔值,那么你应该将它声明为 volatile(以提供跨线程的更改可见性)并使用该布尔值运行无体循环一个条件:

      //.....some class
      
      volatile boolean someBoolean; 
      
      Thread someThread = new Thread() {
      
          @Override 
          public void run() {
              //some actions
              while (!someBoolean); //wait for condition 
              //some actions 
          }
      
      };
      

      【讨论】:

      • 这不会占用 CPU 吗?
      • 至少添加 Thread.Sleep(0);但不建议这样做。使用锁定机制。
      【解决方案6】:
      public Boolean test() throws InterruptedException {
          BlockingQueue<Boolean> booleanHolder = new LinkedBlockingQueue<>();
          new Thread(() -> {
              try {
                  TimeUnit.SECONDS.sleep(2);
                  booleanHolder.put(true);
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
          }).start();
          return booleanHolder.poll(4, TimeUnit.SECONDS);
      }
      

      【讨论】:

        猜你喜欢
        • 2012-11-08
        • 1970-01-01
        • 1970-01-01
        • 2022-10-13
        • 1970-01-01
        • 2019-05-28
        • 1970-01-01
        • 1970-01-01
        • 1970-01-01
        相关资源
        最近更新 更多