2020119-多執行緒暫停和喚醒

1. 最近在工作中有涉及到工作流的暫停和喚醒的設計和開發任務,裡面有些坑,拿出來分享下
2. 工作流的暫停和喚醒主要有三種方式:
3. 第一種使用wait(), notify():

• /**
   * 執行緒阻塞/喚醒
   * 2020/11/19
   * chenzhen
   */
  public class MyThread extends Thread {
  
      private boolean isWait =false;
      //
      private final Object lock = new Object();
      //標誌執行緒阻塞情況
      private boolean pause = false;
      //設定執行緒是否阻塞
      public void pauseThread() {
          this.pause = true;
      }
  
      //呼叫該方法實現恢復執行緒的執行
      public void resumeThread() {
          this.pause = false;
          synchronized (lock) {
              //喚醒執行緒
              lock.notify();
          }
      }
  
      //這個方法只能在run方法中實現,不然會阻塞主執行緒,導致頁面無響應
      void onPause() {
          synchronized (lock) {
              try {
                  //執行緒等待/阻塞
                  lock.wait();
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
          }
      }
  
      @Override
      public void run() {
          super.run();
          //標誌執行緒開啟
          isWait = true;
          //一直迴圈
          while (true) {
              if (pause) {
                  //執行緒阻塞/等待
                  onPause();
              }
  
              try {
                  //程式每50毫秒執行一次, 值可更改
                  Thread.sleep(50);
                  //業務邏輯
              } catch (InterruptedException e) {
                  e.printStackTrace();
                  break;
              }
          }
      }
  
      public static void main(String[] args) {
          //1,建立自己的執行緒
          MyThread myThread = new MyThread();
          //2,在合適的地方啟動執行緒
          myThread.start();
          //3,啟動後執行緒的阻塞/暫停
          myThread.pauseThread();
          //4,阻塞/暫停執行緒後喚醒/繼續
          myThread.resumeThread();
      }
  }

  4, 第二種使用 await() 和signal()

• /**
   * 執行緒阻塞/喚醒
   * 2020/11/19
   * chenzhen
   */
  public class Test {
      public static Lock lock = new ReentrantLock();
      public static int count = 0;
  
      public static Condition conditionA = lock.newCondition();
      public static Condition conditionB = lock.newCondition();
  
      public static void main(String[] args) {
          Thread t1 = new Thread() {
              @Override
              public void run() {
                  lock.lock();
                  if (count < 5) {
                      System.out.println("執行緒1未達到業務要求,暫停中,等待執行緒2處理到達到要求後喚醒");
                      try {
                          conditionA.await();// 暫停執行緒並釋放鎖
                          System.out.println("conditionA被喚醒");
                          conditionB.await();
                          System.out.println("conditionB被喚醒");
                          System.out.println("我是執行緒1後面的程式碼");
                      } catch (InterruptedException e) {
                          e.printStackTrace();
                      }
                  }
                  lock.unlock();
              }
          };
  
          Thread t2 = new Thread() {
              @Override
              public void run() {
                  lock.lock();
                  while (count < 10) {
                      count++;
                      System.out.println("執行緒2業務處理中: " + count);
                      try {
                          Thread.sleep(1000);
                          if (count == 5) {
                              conditionA.signal();
                              System.out.println("喚醒執行緒1");
                              lock.unlock();// 呼叫signal()方法後,執行緒2並不會釋放鎖,需要手動釋放執行緒2才會執行
                          }
                      } catch (InterruptedException e) {
                          e.printStackTrace();
                      }
                  }
                  try {
                      lock.lock();// 不加這個會報java.lang.IllegalMonitorStateException
                      System.out.println("等待3秒後conditionB會被喚醒");
                      Thread.sleep(3000);
                      conditionB.signal();
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
                  lock.unlock();// 這裡釋放鎖,執行緒2執行完,執行緒1才會執行
              }
          };
  
          t1.start();
          t2.start();
      }
  }

  5, 第三種使用Jdk6中的LockSupport

• /**
   * 執行緒阻塞/喚醒-使用LockSupport 實現指定執行緒的暫停和喚醒
   * 2020/11/19
   * chenzhen
   */
  public class TestLockSupport {
      public static void main(String[] args) throws Exception {
          Thread thread = new Thread(new Runnable() {
              @Override
              public void run() {
                  System.out.println("start...");
                  LockSupport.park(); //一直wait
                  System.out.println("continue...");
              }
          });
          thread.start();
          Thread.sleep(10000);
          LockSupport.unpark(thread); //指定t執行緒解除wait狀態
  
      }
  }

  6, 專案中的需求是: 系統中有很多工作流在執行,可以手動實現指定工作流暫停和喚醒,我採用的是第三種,

  • park和unpark可以實現類似wait和notify的功能，但是並不和wait和notify交叉，也就是說unpark不會對wait起作用，notify也不會對park起作用。
  • park和unpark的使用不會出現死鎖的情況
  • blocker的作用是在dump執行緒的時候看到阻塞物件的資訊

通過檢視原始碼可以看到park只能暫停當前執行緒,不能暫停指定執行緒, 所以我採用重寫LockSupport方式

/**
 * 執行緒阻塞/喚醒 -自定義LockSupport
 * 2020/11/19
 * chenzhen
 */
public class LockSupportImpl{
    private LockSupportImpl() {} // Cannot be instantiated.

    /**
     * 暫停指定執行緒
     * @param blocker
     * @param t
     */
    public static void park(Object blocker,Thread t) {
        //Thread t = Thread.currentThread();
        setBlocker(t, blocker);
        UNSAFE.park(false, 0L);
        setBlocker(t, null);
    }

    private static void setBlocker(Thread t, Object arg) {
        // Even though volatile, hotspot doesn't need a write barrier here.
        UNSAFE.putObject(t, parkBlockerOffset, arg);
    }

    public static void unpark(Thread thread) {
        if (thread != null)
            UNSAFE.unpark(thread);
    }

    public static void park() {
        UNSAFE.park(false, 0L);
    }


    // Hotspot implementation via intrinsics API
    private static final sun.misc.Unsafe UNSAFE;
    private static final long parkBlockerOffset;
    private static final long SEED;
    private static final long PROBE;
    private static final long SECONDARY;
    static {
        try {
            UNSAFE = sun.misc.Unsafe.getUnsafe();
            Class<?> tk = Thread.class;
            parkBlockerOffset = UNSAFE.objectFieldOffset
                    (tk.getDeclaredField("parkBlocker"));
            SEED = UNSAFE.objectFieldOffset
                    (tk.getDeclaredField("threadLocalRandomSeed"));
            PROBE = UNSAFE.objectFieldOffset
                    (tk.getDeclaredField("threadLocalRandomProbe"));
            SECONDARY = UNSAFE.objectFieldOffset
                    (tk.getDeclaredField("threadLocalRandomSecondarySeed"));
        } catch (Exception ex) { throw new Error(ex); }
    }
}

/**
 * 執行緒阻塞/喚醒
 * 2020/11/19
 * chenzhen
 */
public class Main {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        Thread thread = new Thread(
                () -> {
                    //業務邏輯省略
                }
        );
        Future<?> submit = executorService.submit(thread);
        LockSupportImpl.park("執行緒:"+thread.getName(),thread);
        LockSupportImpl.unpark(thread);
    }
}

這裡實現了