//打印奇數(shù)的線程
private static class OldRunner implements Runnable{
  private MyNumber n;

  public OldRunner(MyNumber n) {
    this.n = n;
  }

  public void run() {
    while (true){
      n.waitToOld(); //等待數(shù)據(jù)變成奇數(shù)
      System.out.println("old:" + n.getVal());
      n.increase();
      if (n.getVal()>98){
        break;
      }
    }
  }
}
//打印偶數(shù)的線程
private static class EvenRunner implements Runnable{
  private MyNumber n;

  public EvenRunner(MyNumber n) {
    this.n = n;
  }

  public void run() {
    while (true){
      n.waitToEven();      //等待數(shù)據(jù)變成偶數(shù)
      System.out.println("even:"+n.getVal());
      n.increase(); 
      if (n.getVal()>99){
        break;
      }
    }
  }
}

private static class MyNumber{
  private int val;

  public MyNumber(int val) {
    this.val = val;
  }

  public int getVal() {
    return val;
  }
  public synchronized void increase(){
    val++;
    notify(); //數(shù)據(jù)變了，喚醒另外的線程
  }
  public synchronized void waitToOld(){
    while ((val % 2)==0){
      try {
        System.out.println("i am "+Thread.currentThread().getName()+" ,but now is even:"+val+",so wait");
        wait(); //只要是偶數(shù)，一直等待
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
  }
  public synchronized void waitToEven(){
    while ((val % 2)!=0){
      try {
        System.out.println("i am "+Thread.currentThread().getName()+" ,but now old:"+val+",so wait");
        wait(); //只要是奇數(shù)，一直等待
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
  }
}

MyNumber n = new MyNumber(0);
Thread old=new Thread(new OldRunner(n),"old-thread");
Thread even = new Thread(new EvenRunner(n),"even-thread");
old.start();
even.start();

private static class MyNumber{
  private Lock lock = new ReentrantLock();
  private Condition condition = lock.newCondition();
  private int val;

  public MyNumber(int val) {
    this.val = val;
  }

  public int getVal() {
    return val;
  }
  public void increase(){
    lock.lock();
    try {
      val++;
      condition.signalAll(); //通知線程
    }finally {
      lock.unlock();
    }

  }
  public void waitToOld(){
    lock.lock();
    try{
      while ((val % 2)==0){
        try {
          System.out.println("i am should print old ,but now is even:"+val+",so wait");
          condition.await();
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      }
    }finally {
      lock.unlock();
    }
  }
  public void waitToEven(){
    lock.lock(); //顯示的鎖定
    try{
      while ((val % 2)!=0){
        try {
          System.out.println("i am should print even ,but now old:"+val+",so wait");
          condition.await();//執(zhí)行等待
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      }
    }finally {
      lock.unlock(); //顯示的釋放
    }

  }
}

public ReentrantLock() {
  sync = new NonfairSync();
}

public void lock() {
  sync.lock();
}

final void lock() {
  acquire(1);
}

final void lock() {
  if (compareAndSetState(0, 1)) //先看當(dāng)前鎖是不是已經(jīng)被占有了，如果沒(méi)有，就直接將當(dāng)前線程設(shè)置為占有的線程
    setExclusiveOwnerThread(Thread.currentThread());
  else    
    acquire(1); //鎖已經(jīng)被占有的情況下，嘗試獲取
}

public final void acquire(int arg) {
  if (!tryAcquire(arg) &&
    acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) //一旦搶失敗，就會(huì)進(jìn)入隊(duì)列，進(jìn)入隊(duì)列后則是依據(jù)FIFO的原則來(lái)執(zhí)行喚醒
    selfInterrupt();
}

public final boolean release(int arg) {
  if (tryRelease(arg)) {
    Node h = head;
    if (h != null && h.waitStatus != 0)
      unparkSuccessor(h);
    return true;
  }
  return false;
}

protected final boolean tryAcquire(int acquires) {
  final Thread current = Thread.currentThread();
  int c = getState(); //獲取當(dāng)前的同步狀態(tài)
  if (c == 0) {
    //等于0 表示沒(méi)有被其它線程獲取過(guò)鎖
    if (!hasQueuedPredecessors() &&
      compareAndSetState(0, acquires)) {
      //hasQueuedPredecessors 判斷在當(dāng)前線程的前面是不是還有其它的線程，如果有，也就是鎖sync上有一個(gè)等待的線程，那么它不能獲取鎖，這意味著，只有等待時(shí)間最長(zhǎng)的線程能夠獲取鎖，這就是是公平性的體現(xiàn)
      //compareAndSetState 看當(dāng)前在內(nèi)存中存儲(chǔ)的值是不是真的是0，如果是0就設(shè)置成accquires的取值。對(duì)于JAVA，這種需要直接操作內(nèi)存的操作是通過(guò)unsafe來(lái)完成，具體的實(shí)現(xiàn)機(jī)制則依賴(lài)于操作系統(tǒng)。
      //存儲(chǔ)獲取當(dāng)前鎖的線程
      setExclusiveOwnerThread(current);
      return true;
    }
  }
  else if (current == getExclusiveOwnerThread()) {
    //判斷是不是當(dāng)前線程獲取的鎖
    int nextc = c + acquires;
    if (nextc < 0)//一個(gè)線程能夠獲取同一個(gè)鎖的次數(shù)是有限制的，就是int的最大值
      throw new Error("Maximum lock count exceeded");
    setState(nextc); //在當(dāng)前的基礎(chǔ)上再增加一次鎖被持有的次數(shù)
    return true;
  }
  //鎖被其它線程持有，獲取失敗
  return false;
}

final boolean nonfairTryAcquire(int acquires) {
  final Thread current = Thread.currentThread();
  int c = getState();
  if (c == 0) {
    //鎖沒(méi)有被持有
    //可以看到這里會(huì)無(wú)視sync queue中是否有其它線程，只要執(zhí)行到了當(dāng)前線程，就會(huì)去獲取鎖
    if (compareAndSetState(0, acquires)) { 
      setExclusiveOwnerThread(current); //在判斷一次是不是鎖沒(méi)有被占有，沒(méi)有就去標(biāo)記當(dāng)前線程擁有這個(gè)鎖了
      return true;
    }
  }
  else if (current == getExclusiveOwnerThread()) {
    int nextc = c + acquires; 
    if (nextc < 0) // overflow      
      throw new Error("Maximum lock count exceeded");
    setState(nextc);//如果當(dāng)前線程已經(jīng)占有過(guò)，增加占有的次數(shù)
    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) {
    //當(dāng)占有次數(shù)為0的時(shí)候，就認(rèn)為所有的鎖都釋放完畢了
    free = true; 
    setExclusiveOwnerThread(null);
  }
  setState(c); //更新鎖的狀態(tài)
  return free;
}

public boolean tryLock() {
//本質(zhì)上就是執(zhí)行一次非公平的搶鎖
return sync.nonfairTryAcquire(1); 
}