Merge branch 'master' of github.com:sofkyle/CodeBase

Author: sofkyle

Java/concurrency/cooperation/semaphore/ListPool.java

@@ -0,0 +1,56 @@
+package concurrency.cooperation.semaphore;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.Semaphore;
+import java.util.concurrent.locks.Condition;
+import java.util.concurrent.locks.ReentrantLock;
+
+/**
+ * @author: Kyle
+ * @date: 2018/11/20 10:33
+ */
+public class ListPool {
+    private int poolMaxSize = 3;
+
+    private int semaphorePermits = 5;
+
+    private List<String> list = new ArrayList<String>();
+
+    private Semaphore semaphore = new Semaphore(semaphorePermits);
+
+    private ReentrantLock lock = new ReentrantLock();
+
+    private Condition condition = lock.newCondition();
+
+    public ListPool() {
+        for (int i = 0; i < poolMaxSize; i++) {
+            list.add("string_" + (i + 1));
+        }
+    }
+
+    public String get() {
+        String getString = null;
+        try {
+            semaphore.acquire();
+            lock.lock();
+            while (list.size() == 0) {
+                condition.await();
+            }
+            getString = list.remove(0);
+            lock.unlock();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        return getString;
+    }
+
+    public void put(String value) {
+        lock.lock();
+        list.add(value);
+        condition.signalAll();
+        lock.unlock();
+        semaphore.release();
+    }
+}

Java/concurrency/cooperation/semaphore/MultiEnterMultiDealMultiOutService.java

@@ -0,0 +1,27 @@
+package concurrency.cooperation.semaphore;
+
+import java.util.concurrent.Semaphore;
+
+/**
+ * @author Kyle
+ * @create 2018/11/20 09:51
+ */
+public class MultiEnterMultiDealMultiOutService {
+    private Semaphore semaphore = new Semaphore(3);
+
+    public void sayHello() {
+        try {
+            semaphore.acquire();
+            System.out.println("ThreadName=" + Thread.currentThread().getName() + "准备");
+            System.out.println("Begin hello " + System.currentTimeMillis());
+            for (int i = 0; i < 5; i++) {
+                System.out.println(Thread.currentThread().getName() + "打印" + (i + 1));
+            }
+            System.out.println("End hello " + System.currentTimeMillis());
+            semaphore.release();
+            System.out.println("ThreadName=" + Thread.currentThread().getName() + "结束");
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+}

Java/concurrency/cooperation/semaphore/MultiEnterSingleDealMultiOutService.java

@@ -0,0 +1,32 @@
+package concurrency.cooperation.semaphore;
+
+import java.util.concurrent.Semaphore;
+import java.util.concurrent.locks.ReentrantLock;
+
+/**
+ * @author: Kyle
+ * @date: 2018/11/20 10:24
+ */
+public class MultiEnterSingleDealMultiOutService {
+    private Semaphore semaphore = new Semaphore(3);
+
+    private ReentrantLock lock = new ReentrantLock();
+
+    public void sayHello() {
+        try {
+            semaphore.acquire();
+            System.out.println("ThreadName=" + Thread.currentThread().getName() + "准备");
+            lock.lock();
+            System.out.println("Begin hello " + System.currentTimeMillis());
+            for (int i = 0; i < 5; i++) {
+                System.out.println(Thread.currentThread().getName() + "打印" + (i + 1));
+            }
+            System.out.println("End hello " + System.currentTimeMillis());
+            lock.unlock();
+            semaphore.release();
+            System.out.println("ThreadName=" + Thread.currentThread().getName() + "结束");
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+}

Java/concurrency/cooperation/semaphore/MyThread.java

@@ -0,0 +1,18 @@
+package concurrency.cooperation.semaphore;
+
+/**
+ * @author: Kyle
+ * @date: 2018/11/20 10:03
+ */
+public class MyThread extends Thread {
+    private MultiEnterMultiDealMultiOutService multiEnterMultiDealMultiOutService;
+
+    public MyThread(MultiEnterMultiDealMultiOutService multiEnterMultiDealMultiOutService) {
+        this.multiEnterMultiDealMultiOutService = multiEnterMultiDealMultiOutService;
+    }
+
+    @Override
+    public void run() {
+        multiEnterMultiDealMultiOutService.sayHello();
+    }
+}

Java/concurrency/cooperation/semaphore/ProducerAndConsumer.java

@@ -0,0 +1,95 @@
+package concurrency.cooperation.semaphore;
+
+import java.util.concurrent.Semaphore;
+import java.util.concurrent.locks.Condition;
+import java.util.concurrent.locks.ReentrantLock;
+
+/**
+ * @author: Kyle
+ * @date: 2018/11/20 14:04
+ */
+public class ProducerAndConsumer {
+    private volatile Semaphore producerSemaphore = new Semaphore(10);
+
+    private volatile Semaphore consumerSemaphore = new Semaphore(20);
+
+    private volatile ReentrantLock lock = new ReentrantLock();
+
+    private volatile Condition producerCondition = lock.newCondition();
+
+    private volatile Condition consumerCondition = lock.newCondition();
+
+    // Capacity: 4
+    private volatile Object[] capacity = new Object[4];
+
+    private boolean isEmpty() {
+        boolean isEmpty = true;
+        for (int i = 0; i < capacity.length; i++) {
+            if (capacity[i] != null) {
+                isEmpty = false;
+                break;
+            }
+        }
+
+        return isEmpty;
+    }
+
+    private boolean isFull() {
+        boolean isFull = true;
+        for (int i = 0; i < capacity.length; i++) {
+            if (capacity[i] == null) {
+                isFull = false;
+                break;
+            }
+        }
+
+        return isFull;
+    }
+
+    private void produce() {
+        try {
+            producerSemaphore.acquire();
+            lock.lock();
+            while (isFull()) {
+                producerCondition.await();
+            }
+            for (int i = 0; i < capacity.length; i++) {
+                if (capacity[i] == null) {
+                    capacity[i] = "data";
+                    System.out.println(Thread.currentThread().getName() + " produce " + capacity[i]);
+                    break;
+                }
+            }
+            consumerCondition.notifyAll();
+            lock.unlock();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        } finally {
+            producerSemaphore.release();
+        }
+    }
+
+    private void consume() {
+        try {
+            consumerSemaphore.acquire();
+            lock.lock();
+            while (isEmpty()) {
+                consumerCondition.await();
+            }
+            for (int i = 0; i < capacity.length; i++) {
+                if (capacity[i] != null) {
+                    System.out.println(Thread.currentThread().getName() + " consume " + capacity[i]);
+                    capacity[i] = null;
+                    break;
+                }
+            }
+            consumerCondition.notifyAll();
+            lock.unlock();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        } finally {
+            consumerSemaphore.release();
+        }
+
+    }
+}

Java/concurrency/cooperation/semaphore/SemaphoreTest.java

@@ -0,0 +1,29 @@
+package concurrency.cooperation.semaphore;
+
+import org.junit.Test;
+
+import java.io.IOException;
+
+/**
+ * @author: Kyle
+ * @date: 2018/11/20 10:05
+ */
+public class SemaphoreTest {
+
+    @Test
+    public void testMoreToOneService() {
+        MultiEnterMultiDealMultiOutService multiEnterMultiDealMultiOutService = new MultiEnterMultiDealMultiOutService();
+        MyThread[] threads = new MyThread[12];
+
+        for (int i = 0; i < threads.length; i++) {
+            threads[i] = new MyThread(multiEnterMultiDealMultiOutService);
+            threads[i].start();
+        }
+
+        try {
+            System.in.read();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+}