condition用例

Author: wb-hjk570755

src/com/blankj/concurrent/BoundedQueue.java

@@ -1,4 +1,8 @@
 package com.blankj.concurrent;
+import java.util.LinkedList;
+import java.util.concurrent.locks.Condition;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
 
 /**
  * Description:
@@ -9,4 +13,57 @@
  * @version 1.0 2020/9/22
  */
 public class BoundedQueue {
+
+    private LinkedList<Object> buffer;    //生产者容器
+    private int maxSize ;           //容器最大值是多少
+    private Lock lock;
+    private Condition fullCondition;
+    private Condition notFullCondition;
+    BoundedQueue(int maxSize){
+        this.maxSize = maxSize;
+        buffer = new LinkedList<Object>();
+        lock = new ReentrantLock();
+        fullCondition = lock.newCondition();
+        notFullCondition = lock.newCondition();
+    }
+
+    /**
+     * 生产者
+     * @param obj
+     * @throws InterruptedException
+     */
+    public void put(Object obj) throws InterruptedException {
+        lock.lock();    //获取锁
+        try {
+            while (maxSize == buffer.size()){
+                System.out.println("满了，添加的线程进入等待状态");
+                notFullCondition.await();       //满了，添加的线程进入等待状态
+            }
+            buffer.add(obj);
+            fullCondition.signal(); //通知
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    /**
+     * 消费者
+     * @return
+     * @throws InterruptedException
+     */
+    public Object get() throws InterruptedException {
+        Object obj;
+        lock.lock();
+        try {
+            while (buffer.size() == 0){ //队列中没有数据了 线程进入等待状态
+                System.out.println("队列中没有数据了 线程进入等待状态");
+                fullCondition.await();
+            }
+            obj = buffer.poll();
+            notFullCondition.signal(); //通知
+        } finally {
+            lock.unlock();
+        }
+        return obj;
+    }
 }

src/com/blankj/concurrent/BoundedQueueTest.java

@@ -0,0 +1,38 @@
+package com.blankj.concurrent;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+/**
+ * Description:
+ * Copyright: Copyright (c) 2012
+ * Company: keruyun Technology(Beijing) Chengdu Co. Ltd.
+ *
+ * @author huangjk
+ * @version 1.0 2020/9/22
+ */
+public class BoundedQueueTest {
+    public static void main(String[] args) {
+        BoundedQueue boundedQueue = new BoundedQueue(5);
+
+        ExecutorService executorService = Executors.newFixedThreadPool(2);
+        executorService.execute(()->{
+            for (int i=0;i<10000;i++){
+                try {
+                    boundedQueue.put(new Object());
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+        });
+        executorService.execute(()->{
+            for (int i=0;i<10000;i++){
+                try {
+                    boundedQueue.get();
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+        });
+    }
+}

src/com/blankj/concurrent/ConditionUseCase.java

@@ -0,0 +1,66 @@
+package com.blankj.concurrent;
+
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.locks.Condition;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+/**
+ * Description:
+ * Copyright: Copyright (c) 2012
+ * Company: keruyun Technology(Beijing) Chengdu Co. Ltd.
+ *
+ * @author huangjk
+ * @version 1.0 2020/9/22
+ */
+public class ConditionUseCase {
+
+    public Lock lock = new ReentrantLock();
+    public Condition condition = lock.newCondition();
+
+    public static void main(String[] args)  {
+        ConditionUseCase useCase = new ConditionUseCase();
+        ExecutorService executorService = Executors.newFixedThreadPool (2);
+        executorService.execute(new Runnable() {
+            @Override
+            public void run() {
+                useCase.conditionWait();
+            }
+        });
+        executorService.execute(new Runnable() {
+            @Override
+            public void run() {
+                useCase.conditionSignal();
+            }
+        });
+    }
+
+    public void conditionWait()  {
+        lock.lock();
+        try {
+            System.out.println(Thread.currentThread().getName() + "拿到锁了");
+            System.out.println(Thread.currentThread().getName() + "等待信号");
+            condition.await();
+            System.out.println(Thread.currentThread().getName() + "拿到信号");
+        }catch (Exception e){
+
+        }finally {
+            lock.unlock();
+        }
+    }
+    public void conditionSignal() {
+        lock.lock();
+        try {
+            Thread.sleep(5000);
+            System.out.println(Thread.currentThread().getName() + "拿到锁了");
+            condition.signal();
+            System.out.println(Thread.currentThread().getName() + "发出信号");
+        }catch (Exception e){
+
+        }finally {
+            lock.unlock();
+        }
+    }
+
+}