Java并发编程：Lock机制下API用法详解

Author: cicadasmile

java-se-base-parent/model-multy-thread/src/main/java/com/multy/thread/block06lock02/LockAPI01.java

@@ -0,0 +1,73 @@
+package com.multy.thread.block06lock02;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.locks.Condition;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
+public class LockAPI01 {
+
+    private static Lock lock = new ReentrantLock() ;
+    private static Condition condition1 = lock.newCondition() ;
+    private static Condition condition2 = lock.newCondition() ;
+
+    public static void main(String[] args) throws Exception {
+        List<String> dataList = new ArrayList<>() ;
+        ReadList readList = new ReadList(dataList);
+        WriteList writeList = new WriteList(dataList);
+        new Thread(readList).start();
+        TimeUnit.SECONDS.sleep(2);
+        new Thread(writeList).start();
+    }
+    // 读数据线程
+    static class ReadList implements Runnable {
+        private List<String> dataList ;
+        public ReadList (List<String> dataList){
+            this.dataList = dataList ;
+        }
+        @Override
+        public void run() {
+            lock.lock();
+            try {
+                if (dataList.size() != 2){
+                    System.out.println("Read wait...");
+                    condition1.await();
+                }
+                System.out.println("ReadList WakeUp...");
+                for (String element:dataList){
+                    System.out.println("ReadList："+element);
+                }
+                condition2.signalAll();
+            } catch (InterruptedException e){
+                e.fillInStackTrace() ;
+            } finally {
+                lock.unlock();
+            }
+        }
+    }
+    // 写数据线程
+    static class WriteList implements Runnable {
+        private List<String> dataList ;
+        public WriteList (List<String> dataList){
+            this.dataList = dataList ;
+        }
+        @Override
+        public void run() {
+            lock.lock();
+            try {
+                dataList.add("Java") ;
+                dataList.add("C++") ;
+                condition1.signalAll();
+                System.out.println("Write over...");
+                condition2.await();
+                System.out.println("Write WakeUp...");
+            } catch (InterruptedException e){
+                e.fillInStackTrace() ;
+            } finally {
+                lock.unlock();
+            }
+        }
+    }
+}

java-se-base-parent/model-multy-thread/src/main/java/com/multy/thread/block06lock02/LockAPI02.java

@@ -0,0 +1,100 @@
+package com.multy.thread.block06lock02;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.locks.Condition;
+import java.util.concurrent.locks.ReentrantLock;
+
+public class LockAPI02 {
+    public static void main(String[] args) {
+        PrintInfo printInfo = new PrintInfo() ;
+        ExecutorService service =  Executors.newFixedThreadPool(3);
+        service.execute(new PrintA(printInfo));
+        service.execute(new PrintB(printInfo));
+        service.execute(new PrintC(printInfo));
+    }
+}
+class PrintA implements Runnable {
+    private PrintInfo printInfo ;
+    public PrintA (PrintInfo printInfo){
+        this.printInfo = printInfo ;
+    }
+    @Override
+    public void run() {
+        printInfo.printA ();
+    }
+}
+class PrintB implements Runnable {
+    private PrintInfo printInfo ;
+    public PrintB (PrintInfo printInfo){
+        this.printInfo = printInfo ;
+    }
+    @Override
+    public void run() {
+        printInfo.printB ();
+    }
+}
+class PrintC implements Runnable {
+    private PrintInfo printInfo ;
+    public PrintC (PrintInfo printInfo){
+        this.printInfo = printInfo ;
+    }
+    @Override
+    public void run() {
+        printInfo.printC ();
+    }
+}
+class PrintInfo {
+    // 控制下个执行的线程
+    private String info = "A";
+    private ReentrantLock lock = new ReentrantLock();
+    // 三个线程，三个控制条件
+    Condition conditionA = lock.newCondition();
+    Condition conditionB = lock.newCondition();
+    Condition conditionC = lock.newCondition();
+    public void printA (){
+        try {
+            lock.lock();
+            while (!info.equals("A")) {
+                conditionA.await();
+            }
+            System.out.print("A");
+            info = "B";
+            conditionB.signalAll();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        } finally {
+            lock.unlock();
+        }
+    }
+    public void printB (){
+        try {
+            lock.lock();
+            while (!info.equals("B")) {
+                conditionB.await();
+            }
+            System.out.print("B");
+            info = "C";
+            conditionC.signalAll();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        } finally {
+            lock.unlock();
+        }
+    }
+    public void printC (){
+        try {
+            lock.lock();
+            while (!info.equals("C")) {
+                conditionC.await();
+            }
+            System.out.print("C");
+            info = "A";
+            conditionA.signalAll();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        } finally {
+            lock.unlock();
+        }
+    }
+}

java-se-base-parent/model-multy-thread/src/main/java/com/multy/thread/block06lock02/LockAPI03.java

@@ -0,0 +1,67 @@
+package com.multy.thread.block06lock02;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReadWriteLock;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+
+public class LockAPI03 {
+    public static void main(String[] args) throws Exception {
+        DataMap dataMap = new DataMap() ;
+        Thread read = new Thread(new GetRun(dataMap)) ;
+        Thread write = new Thread(new PutRun(dataMap)) ;
+        write.start();
+        Thread.sleep(2000);
+        read.start();
+    }
+}
+class GetRun implements Runnable {
+    private DataMap dataMap ;
+    public GetRun (DataMap dataMap){
+        this.dataMap = dataMap ;
+    }
+    @Override
+    public void run() {
+        System.out.println("GetRun："+dataMap.get("myKey"));
+    }
+}
+class PutRun implements Runnable {
+    private DataMap dataMap ;
+    public PutRun (DataMap dataMap){
+        this.dataMap = dataMap ;
+    }
+    @Override
+    public void run() {
+        dataMap.put("myKey","myValue");
+    }
+}
+class DataMap {
+    Map<String,String> dataMap = new HashMap<>() ;
+    ReadWriteLock rwLock = new ReentrantReadWriteLock() ;
+    Lock readLock = rwLock.readLock() ;
+    Lock writeLock = rwLock.writeLock() ;
+
+    // 读取数据
+    public String get (String key){
+        readLock.lock();
+        try{
+            return dataMap.get(key) ;
+        } finally {
+            readLock.unlock();
+        }
+    }
+    // 写入数据
+    public void put (String key,String value){
+        writeLock.lock();
+        try{
+            dataMap.put(key,value) ;
+            System.out.println("执行写入结束...");
+            Thread.sleep(10000);
+        } catch (Exception e) {
+            System.out.println("Exception...");
+        } finally {
+            writeLock.unlock();
+        }
+    }
+}

java-se-base-parent/model-multy-thread/src/main/java/com/multy/thread/block06lock02/LockAPI04.java

@@ -0,0 +1,33 @@
+package com.multy.thread.block06lock02;
+
+import java.util.concurrent.locks.LockSupport;
+
+public class LockAPI04 {
+    public static void main(String[] args) throws Exception {
+        OrderPay orderPay = new OrderPay("UnPaid") ;
+        Thread orderThread = new Thread(orderPay) ;
+        orderThread.start();
+        Thread.sleep(3000);
+        orderPay.changeState("Pay");
+        LockSupport.unpark(orderThread);
+    }
+}
+class OrderPay implements Runnable {
+    // 支付状态
+    private String orderState ;
+    public OrderPay (String orderState){
+        this.orderState = orderState ;
+    }
+    public synchronized void changeState (String orderState){
+        this.orderState = orderState ;
+    }
+    @Override
+    public void run() {
+        if (orderState.equals("UnPaid")){
+            System.out.println("订单待支付..."+orderState);
+            LockSupport.park(orderState);
+        }
+        System.out.println("orderState="+orderState);
+        System.out.println("订单准备发货...");
+    }
+}