Java中如何使用锁来等待特殊条件？

Question

I have an object:

public class Resource {
    private Lock lock = new ReentrantLock();
    private boolean processed = false;

    public Lock getLock() {
        return lock;
    }

    public boolean isProcessed() {
        return processed;
    }

    public void setProcessed(boolean processed) {
        this.processed = processed;
    }
}

I want to stop the thread "one" untill the thread "two" changes the variable "processed" to true. After "processed" is set to true I want to wake up the thread "one" and continue doing some stuff.

I know that we can use wait and notify methods to organize it but it is very dangerous because of interruptions.
If I will use only wait and notify methods there may be a situation when I wait infinity.
If our wait method is interrupted by some reason, we check that the "process" variable is still false after that we can use wait again like here:

while(true){
    if(!resource.isProcessed()){
       resource.getLock().wait();
    }
    else{
       break;
    }
}

It is dangerous to use the code like this because after we checked "!resource.isProcessed()" and before we use "resource.getLock().wait()" another process can set the "process" to true and call "resource.getLock().notify()" (which will not take any effect because we haven't yet called "wait()").

How to wait for some condition safely? How to notify/unlock safely some condition?

Answer 1

As Peter Lawrey answered in comments there are Condition available in java. (Thank you for pointing)

Here is a copy past of the example which is available in the documentation:

 class BoundedBuffer {
   final Lock lock = new ReentrantLock();
   final Condition notFull  = lock.newCondition(); 
   final Condition notEmpty = lock.newCondition(); 

   final Object[] items = new Object[100];
   int putptr, takeptr, count;

   public void put(Object x) throws InterruptedException {
     lock.lock();
     try {
       while (count == items.length)
         notFull.await();
       items[putptr] = x;
       if (++putptr == items.length) putptr = 0;
       ++count;
       notEmpty.signal();
     } finally {
       lock.unlock();
     }
   }

   public Object take() throws InterruptedException {
     lock.lock();
     try {
       while (count == 0)
         notEmpty.await();
       Object x = items[takeptr];
       if (++takeptr == items.length) takeptr = 0;
       --count;
       notFull.signal();
       return x;
     } finally {
       lock.unlock();
     }
   }
 }

Answer 2

You can use a CountDownLatch to make one thread await until an operation performed by another thread is completed.

Let's suppose T1 and T2 are your threads and they share a CountDownLatch initialized with a counter of 1 . T1 will first await() on the latch, while T2 should perform its operation and then invoke countDown() on the latch to let T1 proceed.

Of course await() in T1 can still be interrupted, so you may want to call it in a loop.

class T1 implements Runnable {
   private final CountDownLatch latch;

   T1(CountDownLatch latch) {
     this.latch = latch;
   }

   public void run() {
      awaitUninterruptibly(latch);
      doWork();
   }

   private void awaitUninterruptibly(CountDownLatch latch) {
      boolean interrupted = false;
      try {
         while (true) {
            try {
               latch.await();
               return;
            } catch (InterruptedException e) {
               interrupted = true;
            }
         }
      } finally {
         if (interrupted) {
            Thread.currentThread().interrupt();
         }
      }
   }
}

class T2 implements Runnable {
   private final CountDownLatch latch;

   T1(CountDownLatch latch) {
      this.latch = latch;
   }

   public void run() {
      doWork();
      latch.countDown();
   }
}