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

  public static void main(String[] args) {

    Thread threadA = new Thread(new Runnable() {

      public void run() {
        try {
          // 模擬耗時(shí)操作之后初始化變量 num
          Thread.sleep(1000);
          num = 1;
          // 初始化完參數(shù)后釋放兩個(gè) 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 沒(méi)有可用的 permit 則等待，如果有則消耗一個(gè)
          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 沒(méi)有可用的 permit 則等待，如果有則消耗一個(gè)
          semaphore.acquire();
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()
            + "獲取到 num 的值為：" + num);
      }
    },"threadC");
    // 同時(shí)開(kāi)啟 3 個(gè)線程
    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) {
    // 同一個(gè)對(duì)象
    final ThreadCommunication2 my = new ThreadCommunication2();
    // 線程 1 設(shè)置 hasDataToProcess 值為 true
    final Thread t1 = new Thread(new Runnable() {
      public void run() {
        my.setHasDataToProcess(true);
      }
    });
    t1.start();
    // 線程 2 取這個(gè)值 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;// (標(biāo)記)默認(rèn)不輸出,即先進(jìn)行輸入后才能輸出
}

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) {// 兩個(gè)Runnable用同一個(gè)Person初始化，就可保證p是同一個(gè)且唯一
        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;// 修改標(biāo)志位
        p.notify();// 喚醒另一個(gè)
      }
    }
  }

}

class Output implements Runnable {
  private Person p;

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

  public void run() {
    // 別忘了while(true)??！
    while (true) {
      synchronized (p) {
        // 仍然是判斷標(biāo)志位，和上面的線程輪流等待，喚醒
        if (!p.flag) {
          try {
            p.wait();
          } catch (InterruptedException e) {
          }
        }
        System.out.println(p.name + "..." + p.gender);
        // 別忘了改變標(biāo)志位和喚醒另一個(gè)
        p.flag = false;// 讓自己回來(lái)等待
        p.notify();// 同一個(gè)鎖，喚醒鎖上的另一個(gè)線程
      }// 問(wèn)題：一個(gè)線程再次進(jìn)入鎖，等待，另一個(gè)進(jìn)程在此前喚醒了，此時(shí)能進(jìn)入鎖執(zhí)行嗎？-->能，wait()即會(huì)釋放鎖，也釋放執(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...男
......