111

concurrent/src/main/java/concurrent/queue/BlockingQueueTestWork.java

@@ -0,0 +1,52 @@
+package concurrent.queue;
+
+import lombok.AllArgsConstructor;
+import lombok.SneakyThrows;
+
+import java.util.concurrent.ArrayBlockingQueue;
+
+@AllArgsConstructor
+public class BlockingQueueTestWork extends Thread {
+    ArrayBlockingQueue<Integer> arrayBlockingQueue;
+    Integer methodNumber;
+
+    @SneakyThrows
+    @Override
+    public void run() {
+        switch (methodNumber) {
+            case 1:
+                offerTest();
+                break;
+            case 2:
+                addTest();
+                break;
+            case 3:
+                putTest();
+                break;
+        }
+    }
+
+    public void offerTest() {
+        boolean offer = arrayBlockingQueue.offer(1);
+        if (!offer) {
+            System.out.println("队列满了");
+            return;
+        }
+        System.out.println("添加成功");
+    }
+
+    public void addTest() {
+        boolean offer = arrayBlockingQueue.add(1);
+        if (!offer) {
+            System.out.println("队列满了");
+            return;
+        }
+        System.out.println("添加成功");
+    }
+
+    public void putTest() throws InterruptedException {
+        arrayBlockingQueue.put(1);
+        System.out.println("添加成功");
+    }
+}
+

concurrent/src/main/java/concurrent/reentrantlock/ReentrantLockFairTest.java

@@ -0,0 +1,92 @@
+package concurrent.reentrantlock;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.SneakyThrows;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
+/**
+ * ReentrantLock 公平锁运行
+ * @ClassName: ReentrantLockNonFairTest
+ * @Date: 2022/1/28 13:48
+ * @author hz21056617
+ * @version V1.0
+ */
+@Data
+@AllArgsConstructor
+public class ReentrantLockFairTest extends Thread {
+    static final Lock lock = new ReentrantLock(true);
+    private Integer number;
+    private CountDownLatch countDownLatch;
+    private Integer methodNumber;
+
+    /**
+     * When an object implementing interface <code>Runnable</code> is used
+     * to create a thread, starting the thread causes the object's
+     * <code>run</code> method to be called in that separately executing
+     * thread.
+     * <p>
+     * The general contract of the method <code>run</code> is that it may
+     * take any action whatsoever.
+     *
+     * @see     Thread#run()
+     */
+    @SneakyThrows
+    @Override
+    public void run() {
+        if (0 == methodNumber) {
+            lockTest();
+        } else if (1 == methodNumber) {
+            tryLockTest();
+        }
+    }
+
+    /**
+     * lock方法测试
+     * @param
+     * @return void
+     * @Date 2022/1/28 15:14
+     * @Author hz21056617
+     * @Version V1.0
+     */
+    @SneakyThrows
+    public void lockTest() {
+        try {
+            lock.lock();
+            System.out.println(number);
+            Thread.sleep(500);
+        }
+        finally {
+            countDownLatch.countDown();
+            lock.unlock();
+        }
+    }
+
+    /**
+     * tryLock方法测试
+     * @param
+     * @return void
+     * @Date 2022/1/28 15:13
+     * @Author hz21056617
+     * @Version V1.0
+     */
+    @SneakyThrows
+    public void tryLockTest() {
+        if (lock.tryLock()) {
+            try {
+                System.out.println(number);
+                Thread.sleep(500);
+            }
+            finally {
+                countDownLatch.countDown();
+                lock.unlock();
+            }
+        } else {
+            countDownLatch.countDown();
+            System.out.println("上个线程还没有执行完呢");
+        }
+    }
+}

concurrent/src/main/java/concurrent/reentrantlock/ReentrantLockNonFairTest.java

@@ -0,0 +1,91 @@
+package concurrent.reentrantlock;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.SneakyThrows;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
+/**
+ * ReentrantLock 非公平锁依次运行
+ * @ClassName: ReentrantLockNonFairTest
+ * @Date: 2022/1/28 13:48
+ * @author hz21056617
+ * @version V1.0
+ */
+@Data
+@AllArgsConstructor
+public class ReentrantLockNonFairTest extends Thread {
+    static final Lock lock = new ReentrantLock();
+    private Integer number;
+    private CountDownLatch countDownLatch;
+    private Integer methodNumber;
+
+    /**
+     * When an object implementing interface <code>Runnable</code> is used
+     * to create a thread, starting the thread causes the object's
+     * <code>run</code> method to be called in that separately executing
+     * thread.
+     * <p>
+     * The general contract of the method <code>run</code> is that it may
+     * take any action whatsoever.
+     *
+     * @see     Thread#run()
+     */
+    @Override
+    public void run() {
+        if (0 == methodNumber) {
+            lockTest();
+        } else if (1 == methodNumber) {
+            tryLockTest();
+        }
+    }
+
+    /**
+     * lock方法测试
+     * @param
+     * @return void
+     * @Date 2022/1/28 15:14
+     * @Author hz21056617
+     * @Version V1.0
+     */
+    @SneakyThrows
+    public void lockTest() {
+        try {
+            lock.lock();
+            System.out.println(number);
+            Thread.sleep(500);
+        }
+        finally {
+            countDownLatch.countDown();
+            lock.unlock();
+        }
+    }
+
+    /**
+     * tryLock方法测试
+     * @param
+     * @return void
+     * @Date 2022/1/28 15:13
+     * @Author hz21056617
+     * @Version V1.0
+     */
+    @SneakyThrows
+    public void tryLockTest() {
+        if (lock.tryLock()) {
+            try {
+                System.out.println(number);
+                Thread.sleep(500);
+            }
+            finally {
+                countDownLatch.countDown();
+                lock.unlock();
+            }
+        } else {
+            countDownLatch.countDown();
+            System.out.println("上个线程还没有执行完呢");
+        }
+    }
+}

concurrent/src/test/java/concurrent/queue/QueueTest.java

@@ -0,0 +1,40 @@
+package concurrent.queue;
+
+
+import org.junit.jupiter.api.Test;
+
+import java.util.concurrent.ArrayBlockingQueue;
+
+public class QueueTest {
+    @Test
+    public void ArrayBlockingQueueOffer() throws InterruptedException {
+        ArrayBlockingQueue<Integer> arrayBlockingQueue = new ArrayBlockingQueue<>(10);
+        for (Integer i = 0; i < 100; i++){
+            new BlockingQueueTestWork(arrayBlockingQueue, 1).start();
+        }
+        Thread.sleep(10000000);
+    }
+
+    @Test
+    public void ArrayBlockingQueueAdd() throws InterruptedException {
+        ArrayBlockingQueue<Integer> arrayBlockingQueue = new ArrayBlockingQueue<>(10);
+        for (Integer i = 0; i < 100; i++){
+            new BlockingQueueTestWork(arrayBlockingQueue, 2).start();
+        }
+        Thread.sleep(10000000);
+    }
+
+    @Test
+    public void ArrayBlockingQueuePut() throws InterruptedException {
+        ArrayBlockingQueue<Integer> arrayBlockingQueue = new ArrayBlockingQueue<>(10);
+        for (Integer i = 0; i < 100; i++){
+            new BlockingQueueTestWork(arrayBlockingQueue, 3).start();
+        }
+        Thread.sleep(10000000);
+    }
+
+    @Test
+    public void reentrantLockNonFairTestTryLock() throws InterruptedException {
+    }
+
+}

concurrent/src/test/java/concurrent/reentrantlock/ReentrantLockTest.java

@@ -0,0 +1,45 @@
+package concurrent.reentrantlock;
+
+
+import org.junit.jupiter.api.Test;
+
+import java.util.concurrent.CountDownLatch;
+
+public class ReentrantLockTest {
+    @Test
+    public void reentrantLockFairTestLock() throws InterruptedException {
+        CountDownLatch countDownLatch = new CountDownLatch(100);
+        for (Integer i = 0; i < 100; i++){
+            new ReentrantLockFairTest(i, countDownLatch, 0).start();
+        }
+        countDownLatch.await();
+    }
+
+    @Test
+    public void reentrantLockFairTestTryLock() throws InterruptedException {
+        CountDownLatch countDownLatch = new CountDownLatch(100);
+        for (Integer i = 0; i < 100; i++){
+            new ReentrantLockFairTest(i, countDownLatch, 1).start();
+        }
+        countDownLatch.await();
+    }
+
+    @Test
+    public void reentrantLockNonFairTestLock() throws InterruptedException {
+        CountDownLatch countDownLatch = new CountDownLatch(100);
+        for (Integer i = 0; i < 100; i++){
+            new ReentrantLockNonFairTest(i, countDownLatch, 0).start();
+        }
+        countDownLatch.await();
+    }
+
+    @Test
+    public void reentrantLockNonFairTestTryLock() throws InterruptedException {
+        CountDownLatch countDownLatch = new CountDownLatch(100);
+        for (Integer i = 0; i < 100; i++){
+            new ReentrantLockNonFairTest(i, countDownLatch, 1).start();
+        }
+        countDownLatch.await();
+    }
+
+}