FairSync与NonfairSync

state 为0，表示锁未被获取

不为0，表示已被获取

 

compareAndSetState(0, acquires)

        获取锁时，设置state为acquires

 

setExclusiveOwnerThread(current)

        获取锁时，设置线程为当前线程

 

可重入：

        已获取到锁时，再次进入时state 加上acquires即可

 

public class ReentrantLock implements Lock, java.io.Serializable {
     private final Sync sync;

     public ReentrantLock(boolean fair) {
         sync = fair ? new FairSync() : new NonfairSync();
     }

     public void lock() {
         sync.lock();
     }

     public void unlock() {
         sync.release(1);     // 这个1表示退出锁1次。
     }

     // 带超时限制的获取
  public boolean tryLock(long timeout, TimeUnit unit)
          throws InterruptedException {
      return sync.tryAcquireNanos(1, unit.toNanos(timeout));
  }

     // 其他代码省略
}

 可以看到，ReentrantLock都是把具体实现委托给内部类而不是直接继承自AbstractQueuedSynchronizer，这样的好处是用户不会看到不需要的方法，也避免了用户错误地使用AbstractQueuedSynchronizer的公开方法而导致错误。

 

ReentrantLock的重入计数是使用AbstractQueuedSynchronizer的state属性的，state大于0表示锁被占用、等于0表示空闲，小于0则是重入次数太多导致溢出了。

 

 

ReentrantLock.Sync 

 

可重入锁内部实现的超类，主要实现了公平与非公平锁的共有方法，并提供了加锁操作的统一抽象：abstract void lock();，还有核心的释放锁的操作。

abstract static class Sync extends AbstractQueuedSynchronizer {
    private static final long serialVersionUID = -5179523762034025860L;

    // 执行Lock.lock()方法，留给子类根据其公平性实现。
    // 子类化的最主要原因是允许非公平的快速路径。
    abstract void lock();

    // 非公平获取
    final boolean nonfairTryAcquire(int acquires) {
        final Thread current = Thread.currentThread();
        int c = getState();
        if (c == 0) {
      // 锁是空闲的，进行加锁必须用CAS来确保即使有多个线程竞争锁也是安全的
            if (compareAndSetState(0, acquires)) {
                // 加锁成功

                // 把当前线程设为锁的持有者，在获取前可用于判断是否是重入。
                setExclusiveOwnerThread(current);
                return true ;
            }
        }
        else if (current == getExclusiveOwnerThread()) {
             // 锁被占用且当前线程是锁的持有者，说明是重入。
            int nextc = c + acquires;
            if (nextc < 0)
                   // 溢出。加锁次数从0开始，加锁与释放操作是对称的，
                   // 所以绝不会是小于0值，小于0只能是溢出。
                throw new Error("Maximum lock count exceeded");

            // 锁被持有的情况下，只有持有者才能更新锁保护的资源，
            // 所以这里不需要用CAS。
            setState(nextc);
            return true ;
        }
        return false ;
    }

    protected final boolean tryRelease(int releases) {
      // 先读取state是为了获得一个读屏障，owner不是volatile的。
        int c = getState() - releases;

        // 只有锁的持有者才能释放锁
        if (Thread.currentThread() != getExclusiveOwnerThread())
            throw new IllegalMonitorStateException();
        boolean free = false;
        if (c == 0) {// 锁重入计数减到0，需要真正释放锁了。
            free = true;
            setExclusiveOwnerThread( null);
        }
    // 如果c为0，写操作完成后，其他线程就会看到锁被释放了，
       // 所以setExclusiveOwnerThread必须在这个写之前完成。
        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; // 以state属性作为加锁次数。
    }

    final boolean isLocked() {
        return getState() != 0;     // 加锁次数为0表示没有被拥有
    }

    private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        s.defaultReadObject();
        setState(0); // reset to unlocked state
    }
}

 

ReentrantLock.FairSync

 

提供公平性的锁实现。实现公平性的关键在于：如果锁被占用且当前线程不是持有者也不是等待队列的第一个，则进入等待队列。

static final class FairSync extends Sync {
    private static final long serialVersionUID = -3000897897090466540L;

    final void lock() {
        acquire(1); //acquire会首先调用tryAcquire，所以公平策略的控制留给tryAcquire。
    }

    // tryAcquire的公平版本。除非是递归调用或没有等待者或者是第一个，否则不授予访问。
    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 ;
    }
}

 

ReentrantLock.NonfairSync

static final class NonfairSync extends Sync {
    private static final long serialVersionUID = 7316153563782823691L;

    // 执行lock。尝试立即闯入，失败就退回常规流程
    final void lock() {
        if (compareAndSetState(0, 1))// 首先进行获取
             // 获取成功，把当前线程设为持有者
            setExclusiveOwnerThread(Thread.currentThread());
        else
             // 获取失败，进入常规流程：acquire会首先调用tryAcquire，
            acquire(1);
    }

    protected final boolean tryAcquire(int acquires) {
        return nonfairTryAcquire(acquires);
    }
}

 

 

获取锁：

//NonfairSync 
final void lock() {  
	if (compareAndSetState(0, 1))  
		setExclusiveOwnerThread(Thread.currentThread());  
	else  
		acquire(1);  
}  
  
  
//FairSync  
final void lock() {  
	acquire(1);  
} 

 

public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

 

1)在资源没有被占用的情况下:

非公平锁是:

                先state+1,然后直接得到锁,

而公平锁则是:

                先尝试去获取锁,如果得到了锁则state+1.

 

2)如果是同一线程,再次申请锁.

两种锁,表现基本一致,可以参考下面的代码块. 

else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }

 

。