标签：System Thread 通信 几种 consumerThread 线程 println new out

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();

   }
}

标签：System,Thread,通信,几种,consumerThread,线程,println,new,out
来源： https://www.cnblogs.com/wscp/p/15586111.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。