分析下reentrantlock

reentrant 英文:可重入的,下面是jdk注释:

A reentrant mutual exclusion Lock with the same basic behavior and semantics as the implicit monitor lock accessed using synchronized methods and statements, but with extended capabilities.A ReentrantLock is owned by the thread last successfully locking, but not yet unlocking it. A thread invoking lock will return, successfully acquiring the lock, when the lock is not owned by another thread. The method will return immediately if the current thread already owns the lock. This can be checked using methods isHeldByCurrentThread(), and getHoldCount().The constructor for this class accepts an optional fairness parameter. When set true, under contention, locks favor granting access to the longest-waiting thread. Otherwise this lock does not guarantee any particular access order. Programs using fair locks accessed by many threads may display lower overall throughput (i.e., are slower; often much slower) than those using the default setting, but have smaller variances in times to obtain locks and guarantee lack of starvation. Note however, that fairness of locks does not guarantee fairness of thread scheduling. Thus, one of many threads using a fair lock may obtain it multiple times in succession while other active threads are not progressing and not currently holding the lock. Also note that the untimed tryLock method does not honor the fairness setting. It will succeed if the lock is available even if other threads are waiting.It is recommended practice to always immediately follow a call to lock with a try block, most typically in a before/after construction such as: class X {   private final ReentrantLock lock = new ReentrantLock();   // ...   public void m() {     lock.lock();  // block until condition holds     try {       // ... method body     } finally {       lock.unlock()     }   } }In addition to implementing the Lock interface, this class defines methods isLocked and getLockQueueLength, as well as some associated protected access methods that may be useful for instrumentation and monitoring.Serialization of this class behaves in the same way as built-in locks: a deserialized lock is in the unlocked state, regardless of its state when serialized.This lock supports a maximum of 2147483647 recursive locks by the same thread. Attempts to exceed this limit result in Error throws from locking methods.

前半段翻译

可重入互斥锁具有与使用同步方法和语句访问的隐式监视锁相同的基本行为和语义，但具有扩展功能。 ReentrantLock由线程拥有，最后一次成功锁定，但尚未解锁。当锁不是由另一个线程拥有时，线程调用锁将返回，成功获取锁。如果当前线程已经拥有该锁，该方法将立即返回。这可以使用方法isHeldByCurrentThread（）和getHoldCount（）来检查。 此类的构造方法接受一个可选的公平 参数。当设置为 true 时，在多个线程的争用下，这些锁倾向于将访问权授予等待时间最长的线程。否则此锁将无法保证任何特定访问顺序。与采用默认设置（使用不公平锁）相比，使用公平锁的程序在许多线程访问时表现为很低的总体吞吐量（即速度很慢，常常极其慢），但是在获得锁和保证锁分配的均衡性时差异较小。不过要注意的是，公平锁不能保证线程调度的公平性。因此，使用公平锁的众多线程中的一员可能获得多倍的成功机会，这种情况发生在其他活动线程没有被处理并且目前并未持有锁时。还要注意的是，未定时的 tryLock 方法并没有使用公平设置。因为即使其他线程正在等待，只要该锁是可用的，此方法就可以获得成功建议做法是始终立即按照一个调用来锁定一个try块，最常见的是在之前/之后的构建，如：

收割我们需要从里面读懂的含义:

• 可重入锁的机理和synchronized方法块和同步代码块的底层机理近似
• 如果拿到锁的线程继续拿锁会立刻返回,isHeldByCurrentThread:是否被调用线程持有了.getHoldCount:0:不持有该锁,可以重复持有多次,会累加该返回值
• trylock 方法凶横暴力,无视公平原则,只要没有被别线程取得锁,他就直接去抢占锁
• 公平锁不能保证线程调度的公平性,线程调度是看cpu的,万一cpu因为概率比较少调度某个线程,那么这个线程就很难抢到锁,毕竟他都没调度去抢锁,所以公平锁实际上只是说,相对公平,好比高考让大家都有出人头地的机会,但是总有废物根本懒得去试一试,就怪不得上帝了

---

大段贴代码了:

/* * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. * Written by Doug Lea(并发大神) with assistance from members of JCP JSR-166(标准) * Expert Group and released to the public domain, as explained at * http://creativecommons.org/publicdomain/zero/1.0/ */package java.util.concurrent.locks;import java.util.*;import java.util.concurrent.*;import java.util.concurrent.atomic.*;/** * @since 1.5(jdk1.5是翻天覆地的变化,因为加入了很多高并发的机制,开天辟地) * @author Doug Lea */public class ReentrantLock implements Lock, java.io.Serializable {    private static final long serialVersionUID = 7373984872572414699L;    /** 同步器是一种代理模式,加了一层壳封装了可重入锁的内部实现机制 */    private final Sync sync;    /**     * 公平同步器和非公平同步器公有的父类,他通过继承利用了aqs的已经实现的同步机制,aqs:AbstractQueuedSynchronizer:抽象基于队列实现的同步器     * */    abstract static class Sync extends AbstractQueuedSynchronizer {        private static final long serialVersionUID = -5179523762034025860L;        /**         *          * 公平锁和非公平锁自己的实现         */        abstract void lock();        /**         * 非公平抢夺锁的方法实现,在公平和非公平锁都有用到         */        final boolean nonfairTryAcquire(int acquires) {            final Thread current = Thread.currentThread();            int c = getState();            if (c == 0) {            //没有人抢到锁,CAS 方式来修改更新的状态,修改成功后,将本线程引用设置为aqs的exclusiveOwnerThread                if (compareAndSetState(0, acquires)) {                    setExclusiveOwnerThread(current);                    return true;                }            }            else if (current == getExclusiveOwnerThread()) {            //如果aqs的exclusiveOwnerThread的引用已经是本线程了,累加设置成state,因为都是本线程做事就是正常的加之后set,不考虑condition race,但是要考虑到可能会溢出,因为Int 累加会溢出这个时候需要报错.                int nextc = c + acquires;                if (nextc < 0) // overflow                    throw new Error("Maximum lock count exceeded");                setState(nextc);                return true;            }            return false;        }        /*        *尝试释放锁,        */        protected final boolean tryRelease(int releases) {        //要重新设置的state值            int c = getState() - releases;            if (Thread.currentThread() != getExclusiveOwnerThread())            //要想释放锁,但是你都不拥有锁,还想释放,抛异常,说明调用者可能有问题                throw new IllegalMonitorStateException();            boolean free = false;            //如果释放到0,说明可重入锁,释放了若干次,把之前入栈的lock都释放了,这个时候设置独占线程为空.同时告诉调用者是否真的释放完锁了,如果没减到目标值直接返回false            if (c == 0) {                free = true;                setExclusiveOwnerThread(null);            }            setState(c);            return free;        }        protected final boolean isHeldExclusively() {            // While we must in general read state before owner,            // we don't need to do so to check if current thread is owner            return getExclusiveOwnerThread() == Thread.currentThread();        }        final ConditionObject newCondition() {            return new ConditionObject();        }        // Methods relayed from outer class        final Thread getOwner() {            return getState() == 0 ? null : getExclusiveOwnerThread();        }        final int getHoldCount() {            return isHeldExclusively() ? getState() : 0;        }        final boolean isLocked() {            return getState() != 0;        }        /**         * Reconstitutes this lock instance from a stream.         * @param s the stream         */        private void readObject(java.io.ObjectInputStream s)            throws java.io.IOException, ClassNotFoundException {            s.defaultReadObject();            setState(0); // reset to unlocked state        }    }    /**     * Sync object for non-fair locks     */    static final class NonfairSync extends Sync {        private static final long serialVersionUID = 7316153563782823691L;        /**         * Performs lock.  Try immediate barge, backing up to normal         * acquire on failure.         */        final void lock() {            if (compareAndSetState(0, 1))             //如果可以尝试第一次就拿到锁就试一试                setExclusiveOwnerThread(Thread.currentThread());            else            //失败了,往上走方法,最后还是会调用tryAcquire:下面的方法,去非            //nonfairTryAcquire(1)               acquire(1);        }        protected final boolean tryAcquire(int acquires) {            return nonfairTryAcquire(acquires);        }    }    /**     * Sync object for fair locks     */    static final class FairSync extends Sync {        private static final long serialVersionUID = -3000897897090466540L;        final void lock() {            acquire(1);        }        /**         * 公平锁核心实现: acquire(1);会调用下面方法         *          */        protected final boolean tryAcquire(int acquires) {            final Thread current = Thread.currentThread();            int c = getState();            if (c == 0) {            //没人占有锁                if (!hasQueuedPredecessors()                    //队列前面没有等待的人                     &&                     //自旋上锁                    compareAndSetState(0, acquires)) {                    //成功后设置独占线程                    setExclusiveOwnerThread(current);                    return true;                }            }            else if (current == getExclusiveOwnerThread()) {                int nextc = c + acquires;                if (nextc < 0)                    throw new Error("Maximum lock count exceeded");                setState(nextc);                return true;            }            return false;        }    }    /**     * Creates an instance of {@code ReentrantLock}.     * This is equivalent to using {@code ReentrantLock(false)}.     */    public ReentrantLock() {        sync = new NonfairSync();    }    /**     * Creates an instance of {@code ReentrantLock} with the     * given fairness policy.     *     * @param fair {@code true} if this lock should use a fair ordering policy     */    public ReentrantLock(boolean fair) {        sync = fair ? new FairSync() : new NonfairSync();    }    /**     * Acquires the lock.     *     * <p>Acquires the lock if it is not held by another thread and returns     * immediately, setting the lock hold count to one.     *     * <p>If the current thread already holds the lock then the hold     * count is incremented by one and the method returns immediately.     *     * <p>If the lock is held by another thread then the     * current thread becomes disabled for thread scheduling     * purposes and lies dormant until the lock has been acquired,     * at which time the lock hold count is set to one.     */    public void lock() {        sync.lock();    }    /**     * Acquires the lock unless the current thread is     * {@linkplain Thread#interrupt interrupted}.     *     * <p>Acquires the lock if it is not held by another thread and returns     * immediately, setting the lock hold count to one.     *     * <p>If the current thread already holds this lock then the hold count     * is incremented by one and the method returns immediately.     *     * <p>If the lock is held by another thread 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.     *     * </ul>     *     * <p>If the lock is acquired by the current thread then the lock hold     * count is set to one.     *     * <p>If the current thread:     *     * <ul>     *     * <li>has its interrupted status set on entry to this method; or     *     * <li>is {@linkplain Thread#interrupt interrupted} while acquiring     * the lock,     *     * </ul>     *     * then {@link InterruptedException} is thrown and the current thread's     * interrupted status is cleared.     *     * <p>In this implementation, as this method is an explicit     * interruption point, preference is given to responding to the     * interrupt over normal or reentrant acquisition of the lock.     *     * @throws InterruptedException if the current thread is interrupted     */    public void lockInterruptibly() throws InterruptedException {        sync.acquireInterruptibly(1);    }    /**     * Acquires the lock only if it is not held by another thread at the time     * of invocation.     *     * <p>Acquires the lock if it is not held by another thread and     * returns immediately with the value {@code true}, setting the     * lock hold count to one. Even when this lock has been set to use a     * fair ordering policy, a call to {@code tryLock()} <em>will</em>     * immediately acquire the lock if it is available, whether or not     * other threads are currently waiting for the lock.     * This &quot;barging&quot; behavior can be useful in certain     * circumstances, even though it breaks fairness. If you want to honor     * the fairness setting for this lock, then use     * {@link #tryLock(long, TimeUnit) tryLock(0, TimeUnit.SECONDS) }     * which is almost equivalent (it also detects interruption).     *     * <p> If the current thread already holds this lock then the hold     * count is incremented by one and the method returns {@code true}.     *     * <p>If the lock is held by another thread then this method will return     * immediately with the value {@code false}.     *     * @return {@code true} if the lock was free and was acquired by the     *         current thread, or the lock was already held by the current     *         thread; and {@code false} otherwise     */    public boolean tryLock() {        return sync.nonfairTryAcquire(1);    }    /**     * Acquires the lock if it is not held by another thread within the given     * waiting time and the current thread has not been     * {@linkplain Thread#interrupt interrupted}.     *     * <p>Acquires the lock if it is not held by another thread and returns     * immediately with the value {@code true}, setting the lock hold count     * to one. If this lock has been set to use a fair ordering policy then     * an available lock <em>will not</em> be acquired if any other threads     * are waiting for the lock. This is in contrast to the {@link #tryLock()}     * method. If you want a timed {@code tryLock} that does permit barging on     * a fair lock then combine the timed and un-timed forms together:     *     * <pre>if (lock.tryLock() || lock.tryLock(timeout, unit) ) { ... }     * </pre>     *     * <p>If the current thread     * already holds this lock then the hold count is incremented by one and     * the method returns {@code true}.     *     * <p>If the lock is held by another thread 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; or     *     * <li>The specified waiting time elapses     *     * </ul>     *     * <p>If the lock is acquired then the value {@code true} is returned and     * the lock hold count is set to one.     *     * <p>If the current thread:     *     * <ul>     *     * <li>has its interrupted status set on entry to this method; or     *     * <li>is {@linkplain Thread#interrupt interrupted} while     * acquiring the lock,     *     * </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 {@code false}     * is returned.  If the time is less than or equal to zero, the method     * will not wait at all.     *     * <p>In this implementation, as this method is an explicit     * interruption point, preference is given to responding to the     * interrupt over normal or reentrant acquisition of the lock, and     * over reporting the elapse of the waiting time.     *     * @param timeout the time to wait for the lock     * @param unit the time unit of the timeout argument     * @return {@code true} if the lock was free and was acquired by the     *         current thread, or the lock was already held by the current     *         thread; and {@code false} if the waiting time elapsed before     *         the lock could be acquired     * @throws InterruptedException if the current thread is interrupted     * @throws NullPointerException if the time unit is null     *     */    public boolean tryLock(long timeout, TimeUnit unit)            throws InterruptedException {        return sync.tryAcquireNanos(1, unit.toNanos(timeout));    }    /**     * Attempts to release this lock.     *     * <p>If the current thread is the holder of this lock then the hold     * count is decremented.  If the hold count is now zero then the lock     * is released.  If the current thread is not the holder of this     * lock then {@link IllegalMonitorStateException} is thrown.     *     * @throws IllegalMonitorStateException if the current thread does not     *         hold this lock     */    public void unlock() {        sync.release(1);    }    /**     * Returns a {@link Condition} instance for use with this     * {@link Lock} instance.     *     * <p>The returned {@link Condition} instance supports the same     * usages as do the {@link Object} monitor methods ({@link     * Object#wait() wait}, {@link Object#notify notify}, and {@link     * Object#notifyAll notifyAll}) when used with the built-in     * monitor lock.     *     * <ul>     *     * <li>If this lock is not held when any of the {@link Condition}     * {@linkplain Condition#await() waiting} or {@linkplain     * Condition#signal signalling} methods are called, then an {@link     * IllegalMonitorStateException} is thrown.     *     * <li>When the condition {@linkplain Condition#await() waiting}     * methods are called the lock is released and, before they     * return, the lock is reacquired and the lock hold count restored     * to what it was when the method was called.     *     * <li>If a thread is {@linkplain Thread#interrupt interrupted}     * while waiting then the wait will terminate, an {@link     * InterruptedException} will be thrown, and the thread's     * interrupted status will be cleared.     *     * <li> Waiting threads are signalled in FIFO order.     *     * <li>The ordering of lock reacquisition for threads returning     * from waiting methods is the same as for threads initially     * acquiring the lock, which is in the default case not specified,     * but for <em>fair</em> locks favors those threads that have been     * waiting the longest.     *     * </ul>     *     * @return the Condition object     */    public Condition newCondition() {        return sync.newCondition();    }    /**     * Queries the number of holds on this lock by the current thread.     *     * <p>A thread has a hold on a lock for each lock action that is not     * matched by an unlock action.     *     * <p>The hold count information is typically only used for testing and     * debugging purposes. For example, if a certain section of code should     * not be entered with the lock already held then we can assert that     * fact:     *     * <pre>     * class X {     *   ReentrantLock lock = new ReentrantLock();     *   // ...     *   public void m() {     *     assert lock.getHoldCount() == 0;     *     lock.lock();     *     try {     *       // ... method body     *     } finally {     *       lock.unlock();     *     }     *   }     * }     * </pre>     *     * @return the number of holds on this lock by the current thread,     *         or zero if this lock is not held by the current thread     */    public int getHoldCount() {        return sync.getHoldCount();    }    /**     * Queries if this lock is held by the current thread.     *     * <p>Analogous to the {@link Thread#holdsLock} method for built-in     * monitor locks, this method is typically used for debugging and     * testing. For example, a method that should only be called while     * a lock is held can assert that this is the case:     *     * <pre>     * class X {     *   ReentrantLock lock = new ReentrantLock();     *   // ...     *     *   public void m() {     *       assert lock.isHeldByCurrentThread();     *       // ... method body     *   }     * }     * </pre>     *     * <p>It can also be used to ensure that a reentrant lock is used     * in a non-reentrant manner, for example:     *     * <pre>     * class X {     *   ReentrantLock lock = new ReentrantLock();     *   // ...     *     *   public void m() {     *       assert !lock.isHeldByCurrentThread();     *       lock.lock();     *       try {     *           // ... method body     *       } finally {     *           lock.unlock();     *       }     *   }     * }     * </pre>     *     * @return {@code true} if current thread holds this lock and     *         {@code false} otherwise     */    public boolean isHeldByCurrentThread() {        return sync.isHeldExclusively();    }    /**     * Queries if this lock is held by any thread. This method is     * designed for use in monitoring of the system state,     * not for synchronization control.     *     * @return {@code true} if any thread holds this lock and     *         {@code false} otherwise     */    public boolean isLocked() {        return sync.isLocked();    }    /**     * Returns {@code true} if this lock has fairness set true.     *     * @return {@code true} if this lock has fairness set true     */    public final boolean isFair() {        return sync instanceof FairSync;    }    /**     * Returns the thread that currently owns this lock, or     * {@code null} if not owned. When this method is called by a     * thread that is not the owner, the return value reflects a     * best-effort approximation of current lock status. For example,     * the owner may be momentarily {@code null} even if there are     * threads trying to acquire the lock but have not yet done so.     * This method is designed to facilitate construction of     * subclasses that provide more extensive lock monitoring     * facilities.     *     * @return the owner, or {@code null} if not owned     */    protected Thread getOwner() {        return sync.getOwner();    }    /**     * Queries whether any threads are waiting to acquire this lock. Note that     * because cancellations may occur at any time, a {@code true}     * return does not guarantee that any other thread will ever     * acquire this lock.  This method is designed primarily for use in     * monitoring of the system state.     *     * @return {@code true} if there may be other threads waiting to     *         acquire the lock     */    public final boolean hasQueuedThreads() {        return sync.hasQueuedThreads();    }    /**     * Queries whether the given thread is waiting to acquire this     * lock. Note that because cancellations may occur at any time, a     * {@code true} return does not guarantee that this thread     * will ever acquire this lock.  This method is designed primarily for use     * in monitoring of the system state.     *     * @param thread the thread     * @return {@code true} if the given thread is queued waiting for this lock     * @throws NullPointerException if the thread is null     */    public final boolean hasQueuedThread(Thread thread) {        return sync.isQueued(thread);    }    /**     * Returns an estimate of the number of threads waiting to     * acquire this lock.  The value is only an estimate because the number of     * threads may change dynamically while this method traverses     * internal data structures.  This method is designed for use in     * monitoring of the system state, not for synchronization     * control.     *     * @return the estimated number of threads waiting for this lock     */    public final int getQueueLength() {        return sync.getQueueLength();    }    /**     * Returns a collection containing threads that may be waiting to     * acquire this lock.  Because the actual set of threads may change     * dynamically while constructing this result, the returned     * collection is only a best-effort estimate.  The elements of the     * returned collection are in no particular order.  This method is     * designed to facilitate construction of subclasses that provide     * more extensive monitoring facilities.     *     * @return the collection of threads     */    protected Collection<Thread> getQueuedThreads() {        return sync.getQueuedThreads();    }    /**     * Queries whether any threads are waiting on the given condition     * associated with this lock. Note that because timeouts and     * interrupts may occur at any time, a {@code true} return does     * not guarantee that a future {@code signal} will awaken any     * threads.  This method is designed primarily for use in     * monitoring of the system state.     *     * @param condition the condition     * @return {@code true} if there are any waiting threads     * @throws IllegalMonitorStateException if this lock is not held     * @throws IllegalArgumentException if the given condition is     *         not associated with this lock     * @throws NullPointerException if the condition is null     */    public boolean hasWaiters(Condition condition) {        if (condition == null)            throw new NullPointerException();        if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))            throw new IllegalArgumentException("not owner");        return sync.hasWaiters((AbstractQueuedSynchronizer.ConditionObject)condition);    }    /**     * Returns an estimate of the number of threads waiting on the     * given condition associated with this lock. Note that because     * timeouts and interrupts may occur at any time, the estimate     * serves only as an upper bound on the actual number of waiters.     * This method is designed for use in monitoring of the system     * state, not for synchronization control.     *     * @param condition the condition     * @return the estimated number of waiting threads     * @throws IllegalMonitorStateException if this lock is not held     * @throws IllegalArgumentException if the given condition is     *         not associated with this lock     * @throws NullPointerException if the condition is null     */    public int getWaitQueueLength(Condition condition) {        if (condition == null)            throw new NullPointerException();        if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))            throw new IllegalArgumentException("not owner");        return sync.getWaitQueueLength((AbstractQueuedSynchronizer.ConditionObject)condition);    }    /**     * Returns a collection containing those threads that may be     * waiting on the given condition associated with this lock.     * Because the actual set of threads may change dynamically while     * constructing this result, the returned collection is only a     * best-effort estimate. The elements of the returned collection     * are in no particular order.  This method is designed to     * facilitate construction of subclasses that provide more     * extensive condition monitoring facilities.     *     * @param condition the condition     * @return the collection of threads     * @throws IllegalMonitorStateException if this lock is not held     * @throws IllegalArgumentException if the given condition is     *         not associated with this lock     * @throws NullPointerException if the condition is null     */    protected Collection<Thread> getWaitingThreads(Condition condition) {        if (condition == null)            throw new NullPointerException();        if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))            throw new IllegalArgumentException("not owner");        return sync.getWaitingThreads((AbstractQueuedSynchronizer.ConditionObject)condition);    }    /**     * Returns a string identifying this lock, as well as its lock state.     * The state, in brackets, includes either the String {@code "Unlocked"}     * or the String {@code "Locked by"} followed by the     * {@linkplain Thread#getName name} of the owning thread.     *     * @return a string identifying this lock, as well as its lock state     */    public String toString() {        Thread o = sync.getOwner();        return super.toString() + ((o == null) ?                                   "[Unlocked]" :                                   "[Locked by thread " + o.getName() + "]");    }}