Java并在另一个线程持有锁时通过同步块

Question

Is it possible to pass over a synchronized block of code when another thread has the synchronized object under lock? If not, is there an alternative that can act in this way?

Answer 1

You can replace the synchronized block with the java.util.concurrent.locks.ReentrantLock class. This class provides very similar mutual exclusion features, but it also has the method tryLock , which acquires the lock if it's free, or returns false immediately if it's taken.

So you can have something like:

 private final ReentrantLock rlock = new ReentrantLock();

Code of thread 1:

 // thread 1 has normal synchronized behavior
 rlock.lock();
 // code
 rlock.unlock();

And thread 2:

 // thread 2 will skip the code if the lock is already taken
 if(rlock.tryLock()) {
     // code
     rlock.unlock();
 }

Answer 2

It can be done with a guard object. The guard object has a function that does this:

1. Lock the guard object.

2. Check if the guard flag is set. If so, return false , unlocking the guard object.

3. Set the guard flag.

4. Return true , unlocking the guard object.

If the caller gets true , it knows it can operate on the guarded object without conflicting with any other threads because only one thread can set the guard flag from false to true until it is set back to false , and other threads only access the object if they have set the guard flag.

When done, re-lock the guard object and clear the guard flag to allow other threads in.

The locking of the guard object can, of course, be implicit through the use of synchronized functions. Usually you don't wind up creating an object just to guard, you fold other functionality associated with why you needed to guard the object into the guard object.