问能够检测某些类型的编程错误的互斥对象。

EN

Combination combination = lock.acquire();
threadPool.submit(() -> {
   try { ... } finally {
       lock.release(combination);
   }
});

public class CombinationLock {

    // This lock is used to synchronize access to the combination field
    private final Lock lock = new ReentrantLock();
    private final Condition lockReleased = lock.newCondition();

    // Initially null, this field is set to a non-null value from acquire/tryAcquire methods
    // and then set to null again from release().
    private Combination combination;

    /**
     * Block the caller thread indefinitely until the lock is acquired
     *
     * @return the combination for releasing the lock
     * @throws InterruptedException if waiting thread is interrupted
     */
    public Combination acquire() throws InterruptedException {
        lock.lockInterruptibly();
        try {
            while (combination != null) {
                lockReleased.await();
            }
            combination = Combination.generate();
            return combination;
        } finally {
            lock.unlock();
        }
    }

    /**
     * Wait for the lock to be available. If available at the time of invocation, lock and return the
     * combination to release it later, otherwise just return null.
     *
     * @return null, or the combination for releasing the lock
     */
    public Combination tryAcquire() throws InterruptedException {
        boolean locked = lock.tryLock();
        if (locked) {
            try {
                if (combination == null) {
                    combination = Combination.generate();
                    return combination;
                } else {
                    return null;
                }
            } finally {
                lock.unlock();
            }
        } else {
            return null;
        }
    }

    /**
     * Wait for the given timeout, otherwise return null
     *
     * @param timeout in arbitrary unit
     * @param unit the timeout unit
     * @return NULL, of the combination to release the lock
     * @throws InterruptedException if thread is interrupted
     */
    public Combination tryAcquire(long timeout, TimeUnit unit) throws InterruptedException {
        Stopwatch stopwatch =  Stopwatch.createStarted();
        boolean locked = lock.tryLock(timeout, unit);
        if (locked) {
            try {
                while (combination != null) {
                    long remainingWaitTimeNanos = unit.toNanos(timeout) - stopwatch.elapsed(TimeUnit.NANOSECONDS);
                    boolean timeRunOut = lockReleased.await(remainingWaitTimeNanos, TimeUnit.NANOSECONDS);
                    if (timeRunOut) {
                        return null;
                    }
                }
                combination = Combination.generate();
                return combination;
            } finally {
                lock.unlock();
            }
        } else {
            return null;
        }
    }

    public boolean isLocked() {
        lock.lock();
        try {
            return combination != null;
        } finally {
            lock.unlock();
        }
    }

    /**
     * Release the lock
     *
     * @param combination previously generated from acquire/tryAcquire
     */
    public void release(Combination combination) {
        Preconditions.checkNotNull(combination, "Given combination must be non-null. Did you forget to check [combination != null] after calling tryAcquire()?");

        lock.lock();
        try {
            if (!isLocked()) {
                throw new RuntimeException("This lock is not locked");
            }

            if (this.combination.equals(combination)) {
                this.combination = null;
                lockReleased.signalAll();
            } else {
                throw new RuntimeException("Someone else acquired the lock since you got your combination so you must have released it");
            }
        } finally {
            lock.unlock();
        }
    }
}