Java中的锁

public class Mutex implements Lock{
    
    private final Sync sync = new Sync();
    
    private static class Sync extends AbstractQueuedSynchronizer{
        
        protected boolean isHeldExclusively() {
            return getState() == 1;
        }
        
        public boolean tryAcquire(int acquires){
            if (compareAndSetState(0, 1)) {
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
            return false;
        }
        
        protected boolean tryRelease(int release){
            if (getState() == 0) {
                throw new IllegalMonitorStateException();
            }
            setExclusiveOwnerThread(null);
            setState(0);
            return true;
        }
        
        Condition newCondition(){
            return new ConditionObject();
        }
    }

    @Override
    public void lock() {
        sync.acquire(1);
    }

    @Override
    public void lockInterruptibly() throws InterruptedException {
        sync.acquireInterruptibly(1);
    }

    @Override
    public boolean tryLock() {
        return sync.tryAcquire(1);
    }

    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        return sync.tryAcquireNanos(1, unit.toNanos(time));
    }

    @Override
    public void unlock() {
        sync.release(1);
    }

    @Override
    public Condition newCondition() {
        return sync.newCondition();
    }

    
}

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

private Node addWaiter(Node mode){
  Node node = new Node(Thread.currentThread(), mode);
  Node pred = tail;
  if(pred != null){
    node.prev = pred;
    if(compareAndSetTail(pred, node)){
      pred.next = node;
      return node;
    }
  }
  enq(node);
  return node;
}


private Node enq(final Node node){
  for(;;){
    Node t = tail;
    if(t == null){
      if(compareAndSetHead(new Node())){
        tail = headl
      }
    }else{
      node.prev = t;
      if(compareAndSetTail(t, node)){
        t.next = node;
        return t;
      }
    }
  }
}

public final void acquireShared(int arg){
  if(tryAcquireShared(arg) < 0){
    doAcquireShared(arg);
  }
}

private void doAcquireShared(int arg){
  final Node node = addWaiter(Node.SHARED);
  boolean failed = true;
  try{
    boolean interrupted = false;
    for(;;){
      final Node p = node.predecessor();
      if(p == head){
        int r = tryAcquireShared(arg);
        if(r >= 0){  
           setHeadAndPropagate(node, r); // difference from shared acquire
           p.next = null;
           if(interrupted){
             selfInterrupt();
           }
           failed = false;
           return ;
        }
      }
      if(shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt()) 
        interrupted = true;
    }  
  } finally{
    if(failed)
      cancelAcquire(node);
  } 
}

public final boolean releaseShared(int arg){
  if(tryReleaseShared(arg)){
    doReleaseShared();
    return true;
  }
  return false;
}

private boolean doAcquireNanos(int arg, long nanosTimeout) throw InterruptedException{
  long lastTime = System.nanoTime();
  final Node node = addWaiter(Node.EXCLUSIVE);
  boolean failed = true;
  try{
    for(;;){
      final Node p = node.predecessor();
      if(p == head && tryAcquire(arg)){
        setHead(node);
        p.next = null;
        failed = false;
        return true;
      }
      if(nanosTimeout <= 0){
        return false;
      }
      if(shouldParkAfterFailedAcquire(p, node) && nanosTimeout > spinForTimeoutThreshold){
        LockSupport.parkNanos(this, nanosTimeout);
      }
      long now = System.nanoTime();
      nanosTimeout -= now - lastTime;
      lastTime = now;
      if(Thread.interrupted()){
        throw new InterruptedException();
      }
    }
  }finally{
      if(failed)
      cancelAcquire(node);
   }
}

public class TwinsLock implements Lock{
    
    private final Sync sync = new Sync(2);
    
    public static final class Sync extends AbstractQueuedSynchronizer{
        
        public Sync(int count) {
            if(count <= 0){
                throw new IllegalArgumentException("count must large than one.");
            }
            setState(count);
        }
        
        public int tryAcquireShared(int reduceCount){
            for(;;){
                int current = getState();
                int newCount = current - reduceCount;
                if (newCount < 0 || compareAndSetState(current, newCount)) {
                    return newCount;
                }
            }
        }
        
        public boolean tryRelease(int returnCount){
            for(;;){
                int current = getState();
                int newCount = current + returnCount;
                if(compareAndSetState(current, newCount)){
                    return true;
                }
            }
        }
    }

    @Override
    public void lock() {
        sync.acquireShared(1);
    }

    @Override
    public void unlock() {
        sync.releaseShared(1);
    }

}

final boolean nonfairTryAcquire(int acquires){
  final Thread current = Thread.currentThread();
  int c = getState();
  if(c == 0){
    if(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;
}

protected final boolean tryRelease(int releases){
  int c = getState() - releases;
  if(Thread.currentThread() != getExclusiveOwnerThread())
    throw new IllegalMonitorStateException();
  boolean free = false;
  if(c == 0){
    free = true;
    setExclusiveOwnerThread(null);
  }
  setState(c);
  return free;
}

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;
}

public class Cache{
  static Map<String, Object> map = new HashMap<String, Object>();
  static ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
  static Lock r = rwl.readLock();
  static Lock w = rwl.writeLock();
 
  public static final Object get(String key){
    r.lock();
    try{
      return map.get(key);
    }finally{
      r.unlock();
    }
  }

  public static final Object put(String key, Object value){
    w.lock();
    try{
      return map.put(key, value);
    }finally{
      w.unlock();
    }
  }

  public static final void clear(){
    w.lock();
    try{
      map.clear();
    }finally{
      w.unlock();
    }
  }
 
}

protected final boolean tryAcquire(int acquires){
  Thread current = Thread.currentThread();
  int c = getState();
  int w = exclusiveCount(c);
  if(c != 0){
    if( w ==0 || current != getExclusiveOwnweThread())
      return false;
    if(w + exclusiveCount(acquires) > MAX_COUNT)
      throw new Error("Maxium lock count exceeded");
    setState(c + acquires);
    return true;
  }
  if(writerShouldBlock() || !compareAndSetState(c, c+acquires))
    return false;
  setExclusiveOwnerThread(current);
  return true;
}

protected final int tryAcquireShared(int unused){
  for(;;){
    int c = getState();
    int nextc = c + (1 << 16);
    if(nextc < c){
      throw new Error("Maximum lock count exceeded");
    }
    if(exclusiveCount(c) != 0 && owner != Thread.currentThread())
      return -1;
    if(compareAndSetState(c, nextc))
      return 1;
  }
}    

public void processData(){
  readLock.lock();
  if(!update){
    readLock.unlock();
    writeLock.lock();
    try{
      if(!update){
        update = true;
      }
      readLock.lock();
    }finally{
      writeLock.unlock();
    }
  }
  try{
    // deal with data
  }finally{
    readLock.unlock();
  }
}

Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();

public void conditionWait() throws InterruptedException{
  lock.lock();
  try{
    condition.await();
  }finally{
    lock.unlock();
  }
}

public void conditionSignal() throws InterruptedException{
  lock.lock();
  try{
    condition.signal();
  }finally{
    lock.unlock();
  }
}

public class BoundQueue<T> {
    private Object[] items;
    private int addIndex, removeIndex, count;
    private Lock lock = new ReentrantLock();
    private Condition notEmpty = lock.newCondition();
    private Condition notFull = lock.newCondition();

    public BoundQueue(int size) {
        items = new Object[size];
    }
    
    public void add(T t) throws InterruptedException{
        lock.lock();
        try {
            while (count == items.length) {
                notFull.await();
            }
            items[addIndex] = t;
            if (++addIndex == items.length) {
                addIndex = 0;
            }
            ++count;
            notEmpty.signal();
        } finally {
            lock.unlock();
        } 
    }
    
    @SuppressWarnings("unchecked")
    public T remove() throws InterruptedException{
        lock.lock();
        try {
            while(count == 0)
                notEmpty.await();
            Object x = items[removeIndex];
            if(++removeIndex == items.length)
                removeIndex = 0;
            --count;
            notFull.signal();
            return (T) x;
        } finally {
            lock.unlock();
        }
    }
}

public final void await() throws InterruptedException{
  if(Thread.interrupted())
    throw new InterruptedException();
  Node node = addConditionWaiter();
  int saveState = fullyRelease(node);
  int interruptMode = 0;
  while(!isOnSyncQueue(node)){
    LockSupport.park(this);
    if((interruptMode = checkInterruptWhileWaiting(node)) != 0)
      break;
  }  
  if(acquireQueued(node, saveState) && interruptMode != THROW_IE)
    interruptMode = REINTERRUPT;
  if(node.nextWaiter != null)
    unlinkCancelledWaiters();
  if(interruptMode != 0) 
    reportInterruptAfterWait(interruptMode);
}

public final void signal(){
  if(!isHeldExclusively()) //检查当前线程是否获取了锁
    throw new IllegalMonitorStateException();
  Node first = firstWaiter;
  if(first != null)
    doSignal(first);
}