import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.LockSupport;
 
public class Demo {
 
  public static void main(String[] args) throws InterruptedException {
    Thread thread = new Thread(() -> {
      System.out.println("park 之前");
      LockSupport.park(); // park 函數(shù)可以將調(diào)用這個(gè)方法的線程掛起
      System.out.println("park 之后");
    });
    thread.start();
    TimeUnit.SECONDS.sleep(5);
    System.out.println("主線程休息了 5s");
    System.out.println("主線程 unpark thread");
    LockSupport.unpark(thread); // 主線程將線程 thread 喚醒 喚醒之后線程 thread 才可以繼續(xù)執(zhí)行
  }
}

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.LockSupport;
 
public class Demo02 {
  public static void main(String[] args) throws InterruptedException {
    Thread thread = new Thread(() -> {
      try {
        TimeUnit.SECONDS.sleep(5);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
      System.out.println("park 之前");
      LockSupport.park(); // 線程 thread 后進(jìn)行 park 操作 
      System.out.println("park 之后");
    });
    thread.start();
    System.out.println("主線程 unpark thread");
    LockSupport.unpark(thread); // 先進(jìn)行 unpark 操作
 
  }
}

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
 
public class Demo03 {
 
  private static final ReentrantLock lock = new ReentrantLock();
  private static final Condition condition = lock.newCondition();
 
  public static void thread() throws InterruptedException {
    lock.lock();
 
    try {
      TimeUnit.SECONDS.sleep(5);
      condition.await();
      System.out.println("等待完成");
    }finally {
      lock.unlock();
    }
  }
 
  public static void mainThread() {
    lock.lock();
    try {
      System.out.println("發(fā)送信號(hào)");
      condition.signal();
    }finally {
      lock.unlock();
      System.out.println("主線程解鎖完成");
    }
  }
 
  public static void main(String[] args) {
    Thread thread = new Thread(() -> {
      try {
        thread();
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    });
    thread.start();
 
    mainThread();
  }
}

private final ReentrantLock lock; // 用于保護(hù)臨界去
private final HashMap<Thread, Integer> permits; // 許可證的數(shù)量
private final HashMap<Thread, Condition> conditions; // 用于喚醒和阻塞線程的條件變量

public Parker() {
  lock = new ReentrantLock();
  permits = new HashMap<>();
  conditions = new HashMap<>();
}

public void park() {
  Thread t = Thread.currentThread(); // 首先得到當(dāng)前正在執(zhí)行的線程
  if (conditions.get(t) == null) { // 如果還沒(méi)有線程對(duì)應(yīng)的condition的話就進(jìn)行創(chuàng)建
    conditions.put(t, lock.newCondition());
  }
  lock.lock();
  try {
    // 如果許可證變量還沒(méi)有創(chuàng)建 或者許可證等于0 說(shuō)明沒(méi)有許可證了 線程需要被掛起
    if (permits.get(t) == null || permits.get(t) == 0) {
      permits.put(t, -1); // 同時(shí)許可證的數(shù)目應(yīng)該設(shè)置為-1
      conditions.get(t).await();
    }else if (permits.get(t) > 0) {
      permits.put(t, 0); // 如果許可證的數(shù)目大于0 也就是為1 說(shuō)明線程已經(jīng)有了許可證因此可以直接被放行 但是需要消耗一個(gè)許可證
    }
  } catch (InterruptedException e) {
    e.printStackTrace();
  } finally {
    lock.unlock();
  }
}

public void unpark(Thread thread) {
  Thread t = thread; // 給線程 thread 發(fā)放一個(gè)許可證
  lock.lock();
  try {
    if (permits.get(t) == null) // 如果還沒(méi)有創(chuàng)建許可證變量 說(shuō)明線程當(dāng)前的許可證數(shù)量等于初始數(shù)量也就是0 因此方法許可證之后 許可證的數(shù)量為 1
      permits.put(t, 1);
    else if (permits.get(t) == -1) { // 如果許可證數(shù)量為-1，則說(shuō)明肯定線程 thread 調(diào)用了park方法，而且線程 thread已經(jīng)被掛起了 因此在 unpark 函數(shù)當(dāng)中不急需要將許可證數(shù)量這是為0 同時(shí)還需要將線程喚醒
      permits.put(t, 0);
      conditions.get(t).signal();
    }else if (permits.get(t) == 0) { // 如果許可證數(shù)量為0 說(shuō)明線程正在執(zhí)行 因此許可證數(shù)量加一
      permits.put(t, 1);
    } // 除此之外就是許可證為1的情況了 在這種情況下是不需要進(jìn)行操作的 因?yàn)樵S可證最大的數(shù)量就是1
  }finally {
    lock.unlock();
  }
}

import java.util.HashMap;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
 
public class Parker {
 
  private final ReentrantLock lock;
  private final HashMap<Thread, Integer> permits;
  private final HashMap<Thread, Condition> conditions;
 
  public Parker() {
    lock = new ReentrantLock();
    permits = new HashMap<>();
    conditions = new HashMap<>();
  }
 
  public void park() {
    Thread t = Thread.currentThread();
    if (conditions.get(t) == null) {
      conditions.put(t, lock.newCondition());
    }
    lock.lock();
    try {
      if (permits.get(t) == null || permits.get(t) == 0) {
        permits.put(t, -1);
        conditions.get(t).await();
      }else if (permits.get(t) > 0) {
        permits.put(t, 0);
      }
    } catch (InterruptedException e) {
      e.printStackTrace();
    } finally {
      lock.unlock();
    }
  }
 
  public void unpark(Thread thread) {
    Thread t = thread;
    lock.lock();
    try {
      if (permits.get(t) == null)
        permits.put(t, 1);
      else if (permits.get(t) == -1) {
        permits.put(t, 0);
        conditions.get(t).signal();
      }else if (permits.get(t) == 0) {
        permits.put(t, 1);
      }
    }finally {
      lock.unlock();
    }
  }
}

void Parker::unpark() {
  int s, status;
  // 進(jìn)行加鎖操作 相當(dāng)于 可重入鎖的 lock.lock()
  status = pthread_mutex_lock(_mutex);
  assert (status == 0, "invariant");
  s = _counter;
  _counter = 1;
  if (s < 1) {
    // 如果許可證小于 1 進(jìn)行下面的操作
    if (WorkAroundNPTLTimedWaitHang) {
      // 這行代碼相當(dāng)于 condition.signal() 喚醒線程
      status = pthread_cond_signal (_cond);
      assert (status == 0, "invariant");
      // 解鎖操作 相當(dāng)于可重入鎖的 lock.unlock()
      status = pthread_mutex_unlock(_mutex);
      assert (status == 0, "invariant");
    } else {
      status = pthread_mutex_unlock(_mutex);
      assert (status == 0, "invariant");
      status = pthread_cond_signal (_cond);
      assert (status == 0, "invariant");
    }
  } else {
    // 如果有許可證 也就是 s == 1 那么不許要將線程掛起
    // 解鎖操作 相當(dāng)于可重入鎖的 lock.unlock()
    pthread_mutex_unlock(_mutex);
    assert (status == 0, "invariant");
  }
}