Lock lock = ...; 
if (lock.tryLock()) { 
try { 
// manipulate protected state 
} finally { 
lock.unlock(); 
} 
} else { 
// perform alternative actions 
} 

package cn.outofmemory.locks;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class App {
 static class NumberWrapper {
  public int value = 1;
 }
 public static void main(String[] args) {
  //初始化可重入锁
  final Lock lock = new ReentrantLock();
  //第一个条件当屏幕上输出到3
  final Condition reachThreeCondition = lock.newCondition();
  //第二个条件当屏幕上输出到6
  final Condition reachSixCondition = lock.newCondition();
  //NumberWrapper只是为了封装一个数字，一边可以将数字对象共享，并可以设置为final
  //注意这里不要用Integer, Integer 是不可变对象
  final NumberWrapper num = new NumberWrapper();
  //初始化A线程
  Thread threadA = new Thread(new Runnable() {
   @Override
      public void run() {
    //需要先获得锁
    lock.lock();
    try {
     System.out.println("threadA start write");
     //A线程先输出前3个数
     while (num.value <= 3) {
      System.out.println(num.value);
      num.value++;
     }
     //输出到3时要signal，告诉B线程可以开始了
     reachThreeCondition.signal();
    }
    finally {
     lock.unlock();
    }
    lock.lock();
    try {
     //等待输出6的条件
     reachSixCondition.await();
     System.out.println("threadA start write");
     //输出剩余数字
     while (num.value <= 9) {
      System.out.println(num.value);
      num.value++;
     }
    }
    catch (InterruptedException e) {
     e.printStackTrace();
    }
    finally {
     lock.unlock();
    }
   }
  }
  );
  Thread threadB = new Thread(new Runnable() {
   @Override
      public void run() {
    try {
     lock.lock();
     while (num.value <= 3) {
      //等待3输出完毕的信号
      reachThreeCondition.await();
     }
    }
    catch (InterruptedException e) {
     e.printStackTrace();
    }
    finally {
     lock.unlock();
    }
    try {
     lock.lock();
     //已经收到信号，开始输出4，5，6
     System.out.println("threadB start write");
     while (num.value <= 6) {
      System.out.println(num.value);
      num.value++;
     }
     //4，5，6输出完毕，告诉A线程6输出完了
     reachSixCondition.signal();
    }
    finally {
     lock.unlock();
    }
   }
  }
  );
  //启动两个线程
  threadB.start();
  threadA.start();
 }
}

voidawait()throwsInterruptedException; 
voidawaitUninterruptibly(); 
longawaitNanos(longnanosTimeout)throwsInterruptedException; 
booleanawait(longtime,TimeUnitunit)throwsInterruptedException; 
booleanawaitUntil(Datedeadline)throwsInterruptedException; 
voidsignal(); 
voidsignalAll();

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class ProductQueue<T> {
 private final T[] items;
 private final Lock lock = new ReentrantLock();
 private Condition notFull = lock.newCondition();
 private Condition notEmpty = lock.newCondition();
 // 
 private int head, tail, count;
 public ProductQueue(int maxSize) {
  items = (T[]) new Object[maxSize];
 }
 public ProductQueue() {
  this(10);
 }
 public void put(T t) throws InterruptedException {
  lock.lock();
  try {
   while (count == getCapacity()) {
    notFull.await();
   }
   items[tail] = t;
   if (++tail == getCapacity()) {
    tail = 0;
   }
   ++count;
   notEmpty.signalAll();
  }
  finally {
   lock.unlock();
  }
 }
 public T take() throws InterruptedException {
  lock.lock();
  try {
   while (count == 0) {
    notEmpty.await();
   }
   T ret = items[head];
   items[head] = null;
   //GC 
   // 
   if (++head == getCapacity()) {
    head = 0;
   }
   --count;
   notFull.signalAll();
   return ret;
  }
  finally {
   lock.unlock();
  }
 }
 public int getCapacity() {
  return items.length;
 }
 public int size() {
  lock.lock();
  try {
   return count;
  }
  finally {
   lock.unlock();
  }
 }
}

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

private transient Node firstWaiter; 
private transient Node lastWaiter; 

private void doSignal(Node first) { 
  do { 
    if ( (firstWaiter = first.nextWaiter) == null) 
      lastWaiter = null; 
    first.nextWaiter = null; 
  } while (!transferForSignal(first) && 
       (first = firstWaiter) != null); 
} 
 
private void doSignalAll(Node first) { 
  lastWaiter = firstWaiter = null; 
  do { 
    Node next = first.nextWaiter; 
    first.nextWaiter = null; 
    transferForSignal(first); 
    first = next; 
  } while (first != null); 
} 

final boolean transferForSignal(Node node) { 
  if (!compareAndSetWaitStatus(node, Node.CONDITION, 0)) 
    return false; 
 
  Node p = enq(node); 
  int c = p.waitStatus; 
  if (c > 0 || !compareAndSetWaitStatus(p, c, Node.SIGNAL)) 
    LockSupport.unpark(node.thread); 
  return true; 
}