import java.util.concurrent.locks.LockSupport;

/** 三種執行緒協作通訊的方式：suspend/resume、wait/notify、park/unpark */
public class Demo6 {
   /** 包子店 */
   public static Object baozidian = null;

   /** 正常的suspend/resume */
   public void suspendResumeTest() throws Exception {
      // 啟動執行緒
      Thread consumerThread = new Thread(() -> {
         if (baozidian == null) { // 如果沒包子，則進入等待
            System.out.println("1、進入等待");
            Thread.currentThread().suspend();
         }
         System.out.println("2、買到包子，回家");
      });
      consumerThread.start();
      // 3秒之後，生產一個包子
      Thread.sleep(3000L);
      baozidian = new Object();
      consumerThread.resume();
      System.out.println("3、通知消費者");
   }

   /** 死鎖的suspend/resume。 suspend並不會像wait一樣釋放鎖，故此容易寫出死鎖程式碼 */
   public void suspendResumeDeadLockTest() throws Exception {
      // 啟動執行緒
      Thread consumerThread = new Thread(() -> {
         if (baozidian == null) { // 如果沒包子，則進入等待
            System.out.println("1、進入等待");
            // 當前執行緒拿到鎖，然後掛起
            synchronized (this) {
               Thread.currentThread().suspend();
            }
         }
         System.out.println("2、買到包子，回家");
      });
      consumerThread.start();
      // 3秒之後，生產一個包子
      Thread.sleep(3000L);
      baozidian = new Object();
      // 爭取到鎖以後，再恢復consumerThread
      synchronized (this) {
         consumerThread.resume();
      }
      System.out.println("3、通知消費者");
   }

   /** 導致程式永久掛起的suspend/resume */
   public void suspendResumeDeadLockTest2() throws Exception {
      // 啟動執行緒
      Thread consumerThread = new Thread(() -> {
         if (baozidian == null) {
            System.out.println("1、沒包子，進入等待");
            try { // 為這個執行緒加上一點延時
               Thread.sleep(5000L);
            } catch (InterruptedException e) {
               e.printStackTrace();
            }
            // 這裡的掛起執行在resume後面
            Thread.currentThread().suspend();
         }
         System.out.println("2、買到包子，回家");
      });
      consumerThread.start();
      // 3秒之後，生產一個包子
      Thread.sleep(3000L);
      baozidian = new Object();
      consumerThread.resume();
      System.out.println("3、通知消費者");
      consumerThread.join();
   }

   /** 正常的wait/notify */
   public void waitNotifyTest() throws Exception {
      // 啟動執行緒
      new Thread(() -> {
         if (baozidian == null) { // 如果沒包子，則進入等待
            synchronized (this) {
               try {
                  System.out.println("1、進入等待");
                  this.wait();
               } catch (InterruptedException e) {
                  e.printStackTrace();
               }
            }
         }
         System.out.println("2、買到包子，回家");
      }).start();
      // 3秒之後，生產一個包子
      Thread.sleep(3000L);
      baozidian = new Object();
      synchronized (this) {
         this.notifyAll();
         System.out.println("3、通知消費者");
      }
   }

   /** 會導致程式永久等待的wait/notify */
   public void waitNotifyDeadLockTest() throws Exception {
      // 啟動執行緒
      new Thread(() -> {
         if (baozidian == null) { // 如果沒包子，則進入等待
            try {
               Thread.sleep(5000L);
            } catch (InterruptedException e1) {
               e1.printStackTrace();
            }
            synchronized (this) {
               try {
                  System.out.println("1、進入等待");
                  this.wait();
               } catch (InterruptedException e) {
                  e.printStackTrace();
               }
            }
         }
         System.out.println("2、買到包子，回家");
      }).start();
      // 3秒之後，生產一個包子
      Thread.sleep(3000L);
      baozidian = new Object();
      synchronized (this) {
         this.notifyAll();
         System.out.println("3、通知消費者");
      }
   }

   /** 正常的park/unpark */
   public void parkUnparkTest() throws Exception {
      // 啟動執行緒
      Thread consumerThread = new Thread(() -> {
         if (baozidian == null) { // 如果沒包子，則進入等待
            System.out.println("1、進入等待");
            LockSupport.park();
         }
         System.out.println("2、買到包子，回家");
      });
      consumerThread.start();
      // 3秒之後，生產一個包子
      Thread.sleep(3000L);
      baozidian = new Object();
      LockSupport.unpark(consumerThread);
      System.out.println("3、通知消費者");
   }

   /** 死鎖的park/unpark */
   public void parkUnparkDeadLockTest() throws Exception {
      // 啟動執行緒
      Thread consumerThread = new Thread(() -> {
         if (baozidian == null) { // 如果沒包子，則進入等待
            System.out.println("1、進入等待");
            // 當前執行緒拿到鎖，然後掛起
            synchronized (this) {
               LockSupport.park();
            }
         }
         System.out.println("2、買到包子，回家");
      });
      consumerThread.start();
      // 3秒之後，生產一個包子
      Thread.sleep(3000L);
      baozidian = new Object();
      // 爭取到鎖以後，再恢復consumerThread
      synchronized (this) {
         LockSupport.unpark(consumerThread);
      }
      System.out.println("3、通知消費者");
   }

   public static void main(String[] args) throws Exception {
      // 對呼叫順序有要求，也要開發自己注意鎖的釋放。這個被棄用的API， 容易死鎖，也容易導致永久掛起。
      // new Demo6().suspendResumeTest();
      // new Demo6().suspendResumeDeadLockTest();
      // new Demo6().suspendResumeDeadLockTest2();

      // wait/notify要求再同步關鍵字裡面使用，免去了死鎖的困擾，但是一定要先呼叫wait，再呼叫notify，否則永久等待了
      // new Demo6().waitNotifyTest();
      // new Demo6().waitNotifyDeadLockTest();

      // park/unpark沒有順序要求，但是park並不會釋放鎖，所有再同步程式碼中使用要注意
      // new Demo6().parkUnparkTest();
      // new Demo6().parkUnparkDeadLockTest();

   }
}