java线程并发包util.concurrent的研究(四)

Lock接口

看看Lock接口的结构和lock接口的具体实现类ReentrantLock，通过对它们的揣摩，能多少知道一些“锁”的工作原理。

Lock接口：

package edu.emory.mathcs.backport.java.util.concurrent.locks;

import edu.emory.mathcs.backport.java.util.concurrent.TimeUnit;

public interface Lock {

    /**

     * 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 <tt>Lock</tt> 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

     * <tt>Lock</tt> implementation.

     *

     **/

void lock();

方法功能：

申请锁

详细描述：

如果当前锁无效（无法获得），则申请该锁的线程将挂起等待直到获得有效的锁。

对实现类的考虑：

具体实现类要能够检测一些使用中的错误（例如死锁）并按照相应情况抛出异常。这些具体的异常情况必须在Lock的实现类中有所体现。

 

    /**

     * Acquires the lock unless the current thread is

     * {@link 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 {@link Thread#interrupt interrupts} the current

     * thread, and interruption of lock acquisition is supported.

     * </ul>

     * <p>If the current thread:

     * <ul>

     * <li>has its interrupted status set on entry to this method; or

     * <li>is {@link Thread#interrupt interrupted} while acquiring

     * the lock, and interruption of lock acquisition is supported,

     * </ul>

     * then {@link InterruptedException} is thrown and the current thread's

     * interrupted status is cleared.

     *

     * <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.

     *

     * <p>A <tt>Lock</tt> 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 <tt>Lock</tt> implementation.

     *

     * @throws InterruptedException if the current thread is interrupted

     * while acquiring the lock (and interruption of lock acquisition is

     * supported).

     *

     * @see Thread#interrupt

     *

     **/

    void lockInterruptibly() throws InterruptedException;

       方法功能：

              申请锁，除非当前申请线程被中断。

       详细描述：

申请锁时如果锁是有效的（未被其它线程所占用），则立即返回；如果锁是无效的，则申请该锁的线程（即称为当前线程）将挂起等待直到获得有效的锁，这时会有两种情况发生：

1．  当前线程获得锁。

2．  当前线程被其它线程所中断，而且锁申请的中断被支持。如果当前线程对这个方法来说存在线程被中断的状态的登记；或者锁申请的中断被支持，则一个InterruptedException异常将被抛出，当前线程的中断状态将被清除。

对实现类的考虑：

       对于某些实现来说支持锁获取的中断可能是不可能的，如果可能也要花费大量的操作。开发人员要注意到这个事实。写实现类的文档时要对它有所说明。一个实现能支持根据在正常方法上的中断而返回。具体实现类要能够检测一些使用中的错误（例如死锁）并按照相应情况抛出异常。这些具体的异常情况必须在Lock的实现类中有所体现。当正在申请锁时（如果申请锁的中断被支持），当前线程被中断，则一个中断异常将被抛出。

 

    /**

     * Acquires the lock only if it is free at the time of invocation.

     * <p>Acquires the lock if it is available and returns immediately

     * with the value <tt>true</tt>.

     * If the lock is not available then this method will return

     * immediately with the value <tt>false</tt>.

     * <p>A typical usage idiom for this method would be:

     * <pre>

     *      Lock lock = ...;

     *      if (lock.tryLock()) {

     *          try {

     *              // manipulate protected state

     *          } finally {

     *              lock.unlock();

     *          }

     *      } else {

     *          // perform alternative actions

     *      }

     * </pre>

     * 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 <tt>true</tt> if the lock was acquired and <tt>false</tt>

     * otherwise.

     **/

      

    boolean tryLock();

方法功能：

只当锁是有效的（没有线程占用）时，才获取锁。

       详细描述：

              如果锁是有效的，则获取锁并立即返回true；否则将立即返回false。

              该方法的典型用例：

                  Lock lock = ...;

                 if (lock.tryLock()) {

               try {

                   // manipulate protected state

               } finally {

                   lock.unlock();

               }

           } else {

               // perform alternative actions

           }

这种用法确保如果锁被获得的话，将被解锁，而如果锁没有被获得的话，不用去尝试解锁。

 

    /**

     * Acquires the lock if it is free within the given waiting time and the

     * current thread has not been {@link Thread#interrupt interrupted}.

     *

     * <p>If the lock is available this method returns immediately

     * with the value <tt>true</tt>.

     * 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 {@link Thread#interrupt interrupts} the current

     * thread, and interruption of lock acquisition is supported; or

     * <li>The specified waiting time elapses

     * </ul>

     * <p>If the lock is acquired then the value <tt>true</tt> is returned.

     * <p>If the current thread:

     * <ul>

     * <li>has its interrupted status set on entry to this method; or

     * <li>is {@link Thread#interrupt interrupted} while acquiring

     * the lock, and interruption of lock acquisition is supported,

     * </ul>

     * then {@link InterruptedException} is thrown and the current thread's

     * interrupted status is cleared.

     * <p>If the specified waiting time elapses then the value <tt>false</tt>

     * is returned.

     * If the time is

     * less than or equal to zero, the method will not wait at all.

     *

     * <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, or reporting a timeout.

     * <p>A <tt>Lock</tt> 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

     * <tt>Lock</tt> implementation.

     *

     * @param time the maximum time to wait for the lock

     * @param unit the time unit of the <tt>time</tt> argument.

     * @return <tt>true</tt> if the lock was acquired and <tt>false</tt>

     * 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).

     *

     * @see Thread#interrupt

     *

     **/

    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;

       方法功能：

              在给定时间内获取锁

       详细描述：

如果在一定的等待时间内锁是有效的，并且当前线程没有被中断的话，当前线程将获得该锁；如果锁是无效的，则当前线程将挂起直到以下的三种情况之一发生：

1．在一定的时间内锁被当前线程获得；

2．其它线程中断了当前线程，并且锁申请的中断被支持；

3．在一定时间内当前线程没有获得锁，即等待时间超出了给定值。

情况1发生时，锁被当前线程获取，并返回true；

情况2发生时，如果对本方法来讲，当前线程的中断状态被登记或者申请锁时，锁申请的中断被支持，则InterruptedException将被抛出，当前线程的中断状态被清除。

情况3发生时，返回false。如果给定的时间期限<=0，则本方法将不作等待。

       对实现类的考虑：

一些实现支持锁获取的中断不大可能，而且如果支持的话将付出大量的操作。开发人员应该注意这种情况。并且实现类必须将此情况写入文档。一个实现类能够在执行方法时被中断并返回，或者报告超时。具体实现类要能够检测一些使用中的错误（例如死锁）并按照相应情况抛出异常。这些具体的异常情况必须在Lock的实现类中有所体现。当正在申请锁时（如果申请锁的中断被支持），当前线程被中断，则一个中断异常将被抛出。

       方法说明：

              参数1：等待时间（超时时间）

              参数2：TimeUnit类对象

              返回值：当获得锁时返回true，当等待超时时返回false。

       异常情况：如果当前线程在获取锁时被中断（锁申请的中断被支持），则InterruptedException被抛出

    /**

     * Releases the lock.

     * <p><b>Implementation Considerations</b>

     * <p>A <tt>Lock</tt> implementation will usually impose

     * restrictions on which thread can release a lock (typically only the

     * holder of the lock can release it) and may throw

     * an (unchecked) exception if the restriction is violated.

     * Any restrictions and the exception

     * type must be documented by that <tt>Lock</tt> implementation.

     **/

void unlock();

方法功能：

       释放锁。

对实现类的建议：

锁实现类可以对能够释放锁的线程附加限制，典型的是锁的持有者能够释放锁，当限制被违背时，一个异常将被抛出。任何限制和异常都必须被写入到实现类的文档中。

 

    /**

     * Returns a new {@link Condition} instance that is bound to this

     * <tt>Lock</tt> 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.

     * <p><b>Implementation Considerations</b>

     * <p>The exact operation of the {@link Condition} instance depends on the

     * <tt>Lock</tt> implementation and must be documented by that

     * implementation.

     *

     * @return A new {@link Condition} instance for this <tt>Lock</tt>

     * instance.

     * @throws UnsupportedOperationException if this <tt>Lock</tt>

     * implementation does not support conditions.

     **/

Condition newCondition();

方法功能：

       返回一个新的被绑定到锁上的条件实例。

详细描述：

在调用本方法等待条件实例返回前，当前线程必须首先获得锁。在等待前要调用Condition.await方法自动释放锁和并且在等待返回前重新申请锁。

       对实例类的建议：

              条件实例操作依靠于锁实现，并且必须写入实例类的文档中。

       方法说明：

              返回值：返回一个新的被绑定到锁上的条件实例。

              异常情况：如果锁不支持条件，则抛出UnsupportedOperationException异常。

 

}

总结一下，lock接口的方法列表

方法名	功能	备注
lock	获取锁	如果获取不到锁的话，当前线程将挂起直到获得锁。我把它称作“死等”式获取。
lockInterruptibly	以可被中断的方式获取锁	如果获取不到锁的话，当前线程将挂起直到获得锁或者当前线程被其他线程中断。我把它称作“悲观死等”式获取。
tryLock	尝试获取锁	如果锁有效的话，当前线程立即获取锁并返回true，否则返回false。我称之为“试探”式获取
tryLock(long time, TimeUnit unit)	具有超时机制的尝试获取锁	如果锁有效的话，当前线程立即获取锁并返回true；否则等待一个给定的时间，如果在这时间内获得锁，则返回true，否则返回false；另外像lockInterruptibly一样线程有可能在获取的过程中被中断。我称之为“试探超时”式获取
releaseLock	释放锁
newCondition	返回当前锁的条件

比较四种lock方法来讲，“试探”式和“试探超时”式获取锁的方式效率较高。而“死等”和“悲观死等”式效率低，而且在并发线程较多时增加了系统的资源开销，并且当持有锁的线程没有释放锁便被kill掉时，那些等待锁的线程将被永远的挂起。