import java.util.concurrent.Semaphore;
public class ThreadCommunication {
  private static int num;
  /**
   * 定義一個信號量，該類內(nèi)部維持了多個線程鎖，可以阻塞多個線程，釋放多個線程， 線程的阻塞和釋放是通過 permit 概念來實現(xiàn)的。線程通過semaphore.acquire()方法獲取 permit，如果當前 semaphore 有 permit 則分配給該線程，如果沒有則阻塞該線程直到 semaphore 調(diào)用 release（）方法釋放 permit。
   * 構造函數(shù)  Semaphore(int permits) ： 創(chuàng)建具有給定的許可數(shù)和非公平的公平設置的 Semaphore
   */
  private static Semaphore semaphore = new Semaphore(0);//表示初始時沒有可用的permit

  public static void main(String[] args) {

    Thread threadA = new Thread(new Runnable() {

      public void run() {
        try {
          // 模擬耗時操作之后初始化變量 num
          Thread.sleep(1000);
          num = 1;
          // 初始化完參數(shù)后釋放兩個 permit
          semaphore.release(2);

        } catch (InterruptedException e) {
          e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()
            + "獲取到 num 的值為：" + num);
      }
    },"threadA");
    Thread threadB = new Thread(new Runnable() {

      public void run() {
        try {
      // 獲取 permit，如果 semaphore 沒有可用的 permit 則等待，如果有則消耗一個
          semaphore.acquire();
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()
            + "獲取到 num 的值為：" + num);
      }
    },"threadB");
    Thread threadC = new Thread(new Runnable() {

      public void run() {
        try {
          // 獲取 permit，如果 semaphore 沒有可用的 permit 則等待，如果有則消耗一個
          semaphore.acquire();
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()
            + "獲取到 num 的值為：" + num);
      }
    },"threadC");
    // 同時開啟 3 個線程
    threadA.start();
    threadB.start();
    threadC.start();

  }
}

package threadLearning.waitSleepExchage;
public class ThreadCommunication2 {
  // 共享的變量
  private boolean hasDataToProcess = false;

  // 取值
  public boolean getHasDataToProcess() {
    return hasDataToProcess;
  }

  // 存值
  public void setHasDataToProcess(boolean hasDataToProcess) {
    this.hasDataToProcess = hasDataToProcess;
  }

  public static void main(String[] args) {
    // 同一個對象
    final ThreadCommunication2 my = new ThreadCommunication2();
    // 線程 1 設置 hasDataToProcess 值為 true
    final Thread t1 = new Thread(new Runnable() {
      public void run() {
        my.setHasDataToProcess(true);
      }
    });
    t1.start();
    // 線程 2 取這個值 hasDataToProcess
    Thread t2 = new Thread(new Runnable() {
      public void run() {
        try {
          // 等待線程 1 完成然后取值
          t1.join();
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
        my.getHasDataToProcess();
        System.out.println("t1 改變以后的值：" + my.getHasDataToProcess());
      }
    });
    t2.start();
  }
}

class Person {
  String name;
  String gender;
  boolean flag = false;// (標記)默認不輸出,即先進行輸入后才能輸出
}

class Input implements Runnable {
  private Person p;
  private int n = 0;

  public Input(Person p) {
    this.p = p;
  }

  public void run() {
    // 別忘了while(true)?。?
    while (true) {
      synchronized (p) {// 兩個Runnable用同一個Person初始化，就可保證p是同一個且唯一
        if (p.flag) {
          try {
            p.wait();
          } catch (InterruptedException e) {
          }

        }
        // not "else"
        if (n == 0) {
          p.name = "Jason";
          p.gender = "男";
        } else {
          p.name = "Lily";
          p.gender = "女";
        }
        n = (n + 1) % 2;//是的n在1和0之間切換取值
        p.flag = true;// 修改標志位
        p.notify();// 喚醒另一個
      }
    }
  }

}

class Output implements Runnable {
  private Person p;

  public Output(Person p) {
    this.p = p;
  }

  public void run() {
    // 別忘了while(true)！！
    while (true) {
      synchronized (p) {
        // 仍然是判斷標志位，和上面的線程輪流等待，喚醒
        if (!p.flag) {
          try {
            p.wait();
          } catch (InterruptedException e) {
          }
        }
        System.out.println(p.name + "..." + p.gender);
        // 別忘了改變標志位和喚醒另一個
        p.flag = false;// 讓自己回來等待
        p.notify();// 同一個鎖，喚醒鎖上的另一個線程
      }// 問題：一個線程再次進入鎖，等待，另一個進程在此前喚醒了，此時能進入鎖執(zhí)行嗎？-->能，wait()即會釋放鎖，也釋放執(zhí)行資格！
    }
  }
}

public class WaitSleepTest1 {
  public static void main(String[] args) {
    Person p = new Person();

    new Thread(new Input(p)).start();
    new Thread(new Output(p)).start();
  }
}

Jason...男
Lily...女
Jason...男
Lily...女
Jason...男
Lily...女
Jason...男
Lily...女
Jason...男
Lily...女
Jason...男
......