ReentrantLock有以下几个特性。基本的获取锁操作，基本的释放锁操作，可轮询的锁获取操作，可中断的获取锁操作，定时获取锁操作，使用公平队列。

 
 
首先ReentrantLock的实现主要是依赖于
AbstractQueuedSynchronizer。AbstractQueuedSynchronizer它维护一个状态信息单一的整数
state。state在此用来表示拥有锁的线程请求获取锁的次数。
state==0表示锁为可获取状态。
 
 
 
基本的获取锁操作:lock()方法：
public void lock() {
sync.lock();
}
sync为ReentrantLock静态内部类Sync的一个引用。
无参数的构造函数默认sync指向一个NonfairSync().（不公平队列）。Sync扩展了AbstractQueuedSynchronizer.而NonfairSync扩展了Sync.
NonfairSync中lock()方法的实现如下：
Java代码
  1. final void lock() {
  2. if (compareAndSetState(0, 1))//AbstractQueuedSynchronizer的方法（原子操作）,如果当前的state的值为0则把state的值设为1
  3. setExclusiveOwnerThread(Thread.currentThread());//设置当前锁的有占有者为当前线程
  4. else
  5. acquire(1);//如果是拥有锁的线程请求state++,否则当前线程阻塞，并且把线程存储到阻塞队列中。（AbstractQueuedSynchronizer中使用链表来维护的线程阻塞队列）
  6. }
final void lock() {            if (compareAndSetState(0, 1))//AbstractQueuedSynchronizer的方法（原子操作）,如果当前的state的值为0则把state的值设为1                setExclusiveOwnerThread(Thread.currentThread());//设置当前锁的有占有者为当前线程            else                acquire(1);//如果是拥有锁的线程请求state++,否则当前线程阻塞，并且把线程存储到阻塞队列中。（AbstractQueuedSynchronizer中使用链表来维护的线程阻塞队列）        }
 
 
可轮询的锁获取操作：具体的实现为：
Java代码
  1. final boolean nonfairTryAcquire(int acquires) {
    //此处acquirs为1
  2. final Thread current = Thread.currentThread();
  3. int c = getState();
  4. if (c == 0) {
    //如果state为0证明锁可获取
  5. if (compareAndSetState(0, acquires)) {
    //原子操作，如果当前的state为0，则把state的值设置为1.
  6. setExclusiveOwnerThread(current);//设置当前锁的占有者为当前线程
  7. return true;
  8. }
  9. }
  10. else if (current == getExclusiveOwnerThread()) {
    //如果当前锁的占有者为当前线程
  11. int nextc = c + acquires;
  12. if (nextc < 0) // overflow
  13. throw new Error("Maximum lock count exceeded");
  14. setState(nextc);//设置state为占有锁线程请求锁的次数
  15. return true;
  16. }
  17. return false;
  18. }