package com.example.demo.Lock;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;

public class MyNonLock implements Lock, java.io.Serializable {
 
 //創(chuàng)建一個(gè)具體的MySync來做具體的工作
 private final MySync mySync = new MySync();

 @Override
 public void lock() {
 mySync.acquire(1);
 }

 @Override
 public boolean tryLock() {
 return mySync.tryAcquire(1);
 }
 
 @Override
 public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
 return mySync.tryAcquireNanos(1, unit.toNanos(time));
 
 }
 
 //帶了Interruptibly的方法表示對(duì)中斷進(jìn)行響應(yīng)，就是當(dāng)一個(gè)線程在阻塞隊(duì)列中被掛起的時(shí)候，
 //其他線程調(diào)用該線程的中斷方法中斷了該線程，該線程會(huì)拋出InterruptedException異常
 @Override
 public void lockInterruptibly() throws InterruptedException {
  mySync.acquireInterruptibly(1);
 }

 @Override
 public void unlock() {
 mySync.release(1);
 }

 //很方便的獲取條件變量
 @Override
 public Condition newCondition() {
 return mySync.newCondition();
 }
 
 

 private static class MySync extends AbstractQueuedSynchronizer {

 // 鎖是否已經(jīng)被持有
 protected boolean isHeldExclusively() {
  return getState() == 1;
 }

 // 如果state為0，就嘗試獲取鎖，將state修改為1
 public boolean tryAcquire(int acquires) {
  assert acquires == 1;
  if (compareAndSetState(0, 1)) {
  setExclusiveOwnerThread(Thread.currentThread());
  return true;
  }
  return false;
 }

 // 嘗試釋放鎖，將state設(shè)置為0
 protected boolean tryRelease(int releases) {
  assert releases == 1;
  if (getState() == 0) {
  throw new IllegalMonitorStateException();
  }
  setExclusiveOwnerThread(null);
  setState(0);
  return true;
 }

 //提供條件變量接口
 Condition newCondition() {
  return new ConditionObject();
 }
 }

}

package com.example.demo.study;

import java.util.Queue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.locks.Condition;

import com.example.demo.Lock.MyNonLock;

public class Study0202 {
 // 我們往這個(gè)隊(duì)列中添加字符串
 final static Queue<String> queue = new LinkedBlockingQueue<String>();
 // 創(chuàng)建我們自己的鎖對(duì)象
 final static MyNonLock lock = new MyNonLock();
 // 當(dāng)隊(duì)列queue中字符串滿了，其他的生產(chǎn)線程就丟到這個(gè)條件隊(duì)列里面
 final static Condition full = lock.newCondition();
 // 當(dāng)隊(duì)列queue是空的，其余的消費(fèi)線程就丟到這個(gè)條件隊(duì)列里面
 final static Condition empty = lock.newCondition();
 // 隊(duì)列queue中存字符串最多只能是3個(gè)
 final static int queue_MAX_SIZE = 3;

 //往隊(duì)列queue中壓入字符串
 public static void add() {
 lock.lock();
 try {
  // 當(dāng)隊(duì)列滿了，就將其他生產(chǎn)線程丟進(jìn)full的條件隊(duì)列中
  while (queue.size() == queue_MAX_SIZE) {
  full.await();
  }
  System.out.println("prd:" + "hello");
  // 往隊(duì)列queue中添加字符串
  queue.add("hello");
  // 生產(chǎn)成功，喚醒消費(fèi)條件隊(duì)列中的所有線程趕緊去消費(fèi)
  empty.signalAll();
 } catch (Exception e) {
  //
 } finally {
  lock.unlock();
 }
 }

 //從隊(duì)列queue彈出字符串
 public static void poll() {
 lock.lock();
 try {
  // 當(dāng)隊(duì)列queue中一個(gè)字符串都沒有，就將剩下的消費(fèi)線程丟進(jìn)enpty對(duì)應(yīng)的隊(duì)列中
  while (queue.size() == 0) {
  empty.await();
  }
  // 消費(fèi)隊(duì)列queue中的字符串
  String poll = queue.poll();
  System.out.println("consumer:" + poll);
  // 消費(fèi)成功，就喚醒full中所有的生產(chǎn)線程去生產(chǎn)字符串
  full.signalAll();
 } catch (Exception e) {
  //
 } finally {
  lock.unlock();
 }
 }

 public static void main(String[] args) {
 // 生產(chǎn)者線程
 for (int i = 0; i < 5; i++) {
  new Thread(() -> {
  add();
  }).start();
 }

 // 消費(fèi)者線程
 for (int i = 0; i < 5; i++) {
  new Thread(() -> {
  poll();
  }).start();
 }
 }
}