1 class Mutex implements Lock{
 2     //静态内部类，自定义同步器
 3     private static class Sync extends AbstractQueuedSynchronizer{
 4         //是否处于占用状态
 5         protected boolean isHeldExclusively(){
 6             return getState() == 1;
 7         }
 8         //当状态为0的时候获取锁
 9         public boolean tryAcquire(int acquires){
10             if (compareAndSetState(0,1)){
11                 setExclusiveOwnerThread(Thread.currentThread());//设置当前拥有独占访问的线程。null 参数表示没有线程拥有访问。
12                 return true;
13             }
14             return false;
15         }
16         //释放锁，将状态设置为0
17         protected boolean tryRelease(int releases){
18             if (getState() == 0) throw new IllegalMonitorStateException();
19             setExclusiveOwnerThread(null);
20             setState(0);
21             return true;
22         }
23         //返回一个Condition，每个condition都包含了一个condition队列
24         Condition newCondition(){return new ConditionObject();}
25     }
26     //仅需要将操作代理到Sync上即可
27     private final Sync sync = new Sync();
28     public void lock(){sync.acquire(1);}// 以独占模式获取对象，忽略中断。
29     public boolean tryLock(){return sync.tryAcquire(1);}
30     public void unlock(){sync.release(1);}
31     public Condition newCondition(){return sync.newCondition();}
32     public boolean isLocked(){return sync.isHeldExclusively();}
33     public boolean hasQueuedThreads(){return sync.hasQueuedThreads();}
34     public void lockInterruptibly() throws InterruptedException{
35         sync.acquireInterruptibly(1);
36     }
37     public boolean tryLock(long timeout, TimeUnit unit) throws InterruptedException{
38         return sync.tryAcquireNanos(1,unit.toNanos(timeout));
39     }
40 }