AQS 框架之 Lock 接口

//标准用法
Lock lock = new ReentrantLock();
//获取锁应在try之前，因为若获取锁时发生异常，异常抛出同时会导致锁无故释放
lock.lock();
try{
    doSometing();
}finally{
    //注意：必须在finally块中释放锁，目的是保证在获取到锁之后，最终能被释放
    lock.unlock();
}

/**
 * Acquires the lock.
 *  获取锁，调用该方法的当前线程将会获取锁，当锁获得后，从该方法返回
 * <p>If the lock is not available then the current thread becomes
 * disabled for thread scheduling purposes and lies dormant until the
 * lock has been acquired.
 *  若当前锁不可用(已被占有)，当前线程会一直休眠直到锁为可被获取状态
 * <p><b>Implementation Considerations</b>
 *  实现该方法的注意事项
 * <p>A {@code Lock} implementation may be able to detect erroneous use
 * of the lock, such as an invocation that would cause deadlock, and
 * may throw an (unchecked) exception in such circumstances.  The
 * circumstances and the exception type must be documented by that
 * {@code Lock} implementation.
 *  该方法的实现需要能发现lock被错误使用，如死锁或抛出不可查异常(即可运行期异常和Error)
 *  此时该实现必须用文档注明其可能出现的异常或需要的使用环境
 */
void lock();

//样例代码
public boolean doTask throws InterruptedException(){
    lock.lockInterruptibly();
    try{
        return cancelTask();
    }finally{
        lock.unlock();
    }
}
//取消任务
private boolean cancelTask() throws InterruptedException {...}

/**
 * Acquires the lock unless the current thread is
 * {@linkplain Thread#interrupt interrupted}.
 *      可中断地获取锁，即在锁的获取中可以中断当前线程
 * <p>Acquires the lock if it is available and returns immediately.
 *  当获取锁时锁可用就立即返回
 * <p>If the lock is not available then the current thread becomes
 * disabled for thread scheduling purposes and lies dormant until
 * one of two things happens:
 * <ul>
 * <li>The lock is acquired by the current thread; or
 * <li>Some other thread {@linkplain Thread#interrupt interrupts} the
 * current thread, and interruption of lock acquisition is supported.
 * </ul>
 *  若当前锁不可用(已被占有)，当前线程会一直休眠直到以下两种情况发生：
 *      1.锁被当前线程获取
 *      2.其他线程中断当前线程，同时锁的获取允许被中断
 * <p><b>Implementation Considerations</b>
 *      实现该方法的注意事项
 * <p>The ability to interrupt a lock acquisition in some
 * implementations may not be possible, and if possible may be an
 * expensive operation.  The programmer should be aware that this
 * may be the case. An implementation should document when this is
 * the case.
 *      该方法属于拓展方法，只有需要中断服务的时候才需要实现它
 * <p>An implementation can favor responding to an interrupt over
 * normal method return.
 *      相对于返回，该方法更适合抛出一个中断响应，比如中断异常
 * @throws InterruptedException if the current thread is
 *         interrupted while acquiring the lock (and interruption
 *         of lock acquisition is supported)
 */
void lockInterruptibly() throws InterruptedException;

/**
 * Acquires the lock only if it is free at the time of invocation.
 *      尝试非阻塞的获取锁，调用该方法后立即返回是否成功获取锁true/false
 * <p>Acquires the lock if it is available and returns immediately
 * with the value {@code true}.
 * If the lock is not available then this method will return
 * immediately with the value {@code false}.
 *      当锁不可用时立即返回false
 * This usage ensures that the lock is unlocked if it was acquired, and
 * doesn't try to unlock if the lock was not acquired.
 *      该实现应确保当锁被获取时是未锁状态，当未被获取时不会尝试解锁
 * @return {@code true} if the lock was acquired and
 *         {@code false} otherwise
 */
boolean tryLock();
/**
 * Acquires the lock if it is free within the given waiting time and the
 * current thread has not been {@linkplain Thread#interrupt interrupted}.
 *      没有被中断当前线程在指定超时时间内获取锁
 * If the lock is not available then the current thread becomes disabled for
 * thread scheduling purposes and lies dormant until one of three things happens:
 * <ul>
 * <li>The lock is acquired by the current thread; or
 * <li>Some other thread {@linkplain Thread#interrupt interrupts} the
 * current thread, and interruption of lock acquisition is supported; or
 * <li>The specified waiting time elapses
 * </ul>
 * <p>If the specified waiting time elapses then the value {@code false} is returned.
 * If the time is less than or equal to zero, the method will not wait at all.
 *      当前线程在以下三种情况下会返回：
 *          1.当前线程在超时时间内获得锁
 *          2.当前线程在超时时间内被中断
 *          3.超时时间结束，返回false，线程不再被阻塞
 * @param time the maximum time to wait for the lock
 * @param unit the time unit of the {@code time} argument
 * @return {@code true} if the lock was acquired and {@code false}
 *         if the waiting time elapsed before the lock was acquired
 * @throws InterruptedException if the current thread is interrupted
 *         while acquiring the lock (and interruption of lock
 *         acquisition is supported)
 */
boolean tryLock(long time, TimeUnit unit) throws InterruptedException;    

/**
 * Releases the lock.
 *  释放锁
 */
void unlock();

/**
 * Returns a new {@link Condition} instance that is bound to this
 * {@code Lock} instance.
 *      返回一个等待通知组(条)件
 * <p>Before waiting on the condition the lock must be held by the current thread.
 * A call to {@link Condition#await()} will atomically release the lock
 * before waiting and re-acquire the lock before the wait returns.
 *      该组件与当前锁绑定，当先线程只有获得锁才能调用该组件的await方法并释放锁
 * @return A new {@link Condition} instance for this {@code Lock} instance
 * @throws UnsupportedOperationException if this {@code Lock}
 *         implementation does not support conditions
 */
Condition newCondition();