AQS机制

1     Lock lock = new ReentrantLock(); //可以是自己实现的Lock接口的实现类，也可以是jdk提供的同步组件
2     lock.lock();//一般不能放到try语句中
3      try { 
4     } finally { 
5         lock.unlock(); //一般要求放到finally中，确保即使发生异常也能安全释放掉锁
6     }    

 1 package juc;
 2 import java.util.concurrent.locks.AbstractQueuedSynchronizer;
 3 //Mutex是我们自定的锁
 4 public class Mutex implements java.io.Serializable {
 5     //静态内部类，继承AQS
 6     private static class Sync extends AbstractQueuedSynchronizer {
 7         //是否处于占用状态
 8         protected boolean isHeldExclusively() {
 9             return getState() == 1;
10         }
11         //当状态为0的时候获取锁，CAS操作成功，则state状态为1，
12         public boolean tryAcquire(int acquires) {
13             if (compareAndSetState(0, 1)) {
14                 setExclusiveOwnerThread(Thread.currentThread());
15                 return true;
16             }
17             return false;
18         }
19         //释放锁，将同步状态置为0
20         protected boolean tryRelease(int releases) {
21             if (getState() == 0) throw new IllegalMonitorStateException();
22             setExclusiveOwnerThread(null);
23             setState(0);
24             return true;
25         }
26     }
27         //同步对象完成一系列复杂的操作，我们仅需指向它即可
28         private final Sync sync = new Sync();
29         //加锁操作，代理到acquire（模板方法）上就行，acquire会调用我们重写的tryAcquire方法
30         public void lock() {
31             sync.acquire(1);
32         }
33         public boolean tryLock() {
34             return sync.tryAcquire(1);
35         }
36         //释放锁，代理到release（模板方法）上就行，release会调用我们重写的tryRelease方法。
37         public void unlock() {
38             sync.release(1);
39         }
40         public boolean isLocked() {
41             return sync.isHeldExclusively();
42         }
43 }

 static final Node SHARED = new Node();
        static final Node EXCLUSIVE = null；
        static final int CANCELLED =  1;
        static final int SIGNAL    = -1;
        static final int CONDITION = -2;
        static final int PROPAGATE = -3;
        volatile int waitStatus;//等待状态
        volatile Node prev;//指向前一个结点的指针
        volatile Node next;//指向后一个节点的指针
        volatile Thread thread;//当前结点代表的状态
        Node nextWaiter;