java-multithread lock包更新至example10,lock包告一段落

brianway · brianway · commit 4b6aac105638 · 2016-04-15T21:38:02.000+08:00
diff --git a/java-base/src/main/java/com/brianway/learning/java/base/Boxing.java b/java-base/src/main/java/com/brianway/learning/java/base/Boxing.java
@@ -5,6 +5,7 @@
  */
 
 /**
+ * TODO
  * 待理解。
  * 应该是考装箱和拆箱
  */
diff --git a/java-multithread/src/main/java/com/brianway/learning/java/multithread/lock/example10/Run10_ReadWriteLockBegin1.java b/java-multithread/src/main/java/com/brianway/learning/java/multithread/lock/example10/Run10_ReadWriteLockBegin1.java
@@ -0,0 +1,38 @@
+package com.brianway.learning.java.multithread.lock.example10;
+
+/**
+ * Created by Brian on 2016/4/15.
+ */
+
+/**
+ * P236
+ * 类ReentrantReadWriteLock的使用：读读共享
+ */
+public class Run10_ReadWriteLockBegin1 {
+    public static void main(String[] args) {
+        final Service1 service = new Service1();
+        Thread a = new Thread(){
+            @Override
+            public void run() {
+                service.read();
+            }
+        };
+        Thread b = new Thread(){
+            @Override
+            public void run() {
+                service.read();
+            }
+        };
+        a.setName("A");
+        a.start();
+        b.setName("B");
+        b.start();
+    }
+}
+
+
+/*
+输出：
+获得读锁A 1460726504907
+获得读锁B 1460726504908
+ */
diff --git a/java-multithread/src/main/java/com/brianway/learning/java/multithread/lock/example10/Run10_ReadWriteLockBegin2.java b/java-multithread/src/main/java/com/brianway/learning/java/multithread/lock/example10/Run10_ReadWriteLockBegin2.java
@@ -0,0 +1,38 @@
+package com.brianway.learning.java.multithread.lock.example10;
+
+/**
+ * Created by Brian on 2016/4/15.
+ */
+
+/**
+ * P238
+ * 类ReentrantReadWriteLock的使用：写写互斥
+ */
+public class Run10_ReadWriteLockBegin2 {
+    public static void main(String[] args) {
+        final Service2 service = new Service2();
+        Thread a = new Thread(){
+            @Override
+            public void run() {
+                service.write();
+            }
+        };
+        Thread b = new Thread(){
+            @Override
+            public void run() {
+                service.write();
+            }
+        };
+        a.setName("A");
+        a.start();
+        b.setName("B");
+        b.start();
+    }
+}
+
+
+/*
+输出：
+获得写锁A 1460727106721
+获得写锁B 1460727116721
+ */
diff --git a/java-multithread/src/main/java/com/brianway/learning/java/multithread/lock/example10/Run10_ReadWriteLockBegin3.java b/java-multithread/src/main/java/com/brianway/learning/java/multithread/lock/example10/Run10_ReadWriteLockBegin3.java
@@ -0,0 +1,38 @@
+package com.brianway.learning.java.multithread.lock.example10;
+
+/**
+ * Created by Brian on 2016/4/15.
+ */
+
+/**
+ * P238
+ * 类ReentrantReadWriteLock的使用：读写互斥
+ */
+public class Run10_ReadWriteLockBegin3 {
+    public static void main(String[] args) {
+        final Service3 service = new Service3();
+        Thread a = new Thread(){
+            @Override
+            public void run() {
+                service.read();
+            }
+        };
+        Thread b = new Thread(){
+            @Override
+            public void run() {
+                service.write();
+            }
+        };
+        a.setName("A");
+        a.start();
+        b.setName("B");
+        b.start();
+    }
+}
+
+
+/*
+输出：
+获得读锁 A 1460727280066
+获得写锁 B 1460727290067
+ */
diff --git a/java-multithread/src/main/java/com/brianway/learning/java/multithread/lock/example10/Run10_condition.java b/java-multithread/src/main/java/com/brianway/learning/java/multithread/lock/example10/Run10_condition.java
@@ -0,0 +1,152 @@
+package com.brianway.learning.java.multithread.lock.example10;
+
+/**
+ * Created by Brian on 2016/4/15.
+ */
+
+import java.util.concurrent.locks.Condition;
+import java.util.concurrent.locks.ReentrantLock;
+
+/**
+ * P234
+ * Condition实现顺序打印
+ * 这里nextPrintWho的volatile关键词去掉也没什么影响
+ */
+public class Run10_condition {
+    volatile private static int nextPrintWho =1;
+    private static ReentrantLock lock = new ReentrantLock();
+    final private static Condition conditionA = lock.newCondition();
+    final private static Condition conditionB = lock.newCondition();
+    final private static Condition conditionC = lock.newCondition();
+    public static void main(String[] args) {
+        Thread a = new Thread(){
+            @Override
+            public void run() {
+                try {
+                    lock.lock();
+                    while (nextPrintWho != 1){
+                        conditionA.await();
+                    }
+
+                    for(int i=0;i<3;i++){
+                        System.out.println("ThreadA "+(i+1));
+                    }
+                    nextPrintWho =2;
+                    conditionB.signalAll();
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                } finally {
+                    lock.unlock();
+                }
+            }
+        };
+
+        Thread b = new Thread(){
+            @Override
+            public void run() {
+                try {
+                    lock.lock();
+                    while (nextPrintWho != 2){
+                        conditionB.await();
+                    }
+                    for(int i=0;i<3;i++){
+                        System.out.println("ThreadB "+(i+1));
+                    }
+                    nextPrintWho =3;
+                    conditionC.signalAll();
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                } finally {
+                    lock.unlock();
+                }
+            }
+        };
+
+        Thread c = new Thread(){
+            @Override
+            public void run() {
+                try {
+                    lock.lock();
+                    while (nextPrintWho != 3){
+                        conditionC.await();
+                    }
+                    for(int i=0;i<3;i++){
+                        System.out.println("ThreadC "+(i+1));
+                    }
+                    nextPrintWho = 1 ;
+                    conditionA.signalAll();
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                } finally {
+                    lock.unlock();
+                }
+            }
+        };
+
+        Thread[] aArray = new Thread[5];
+        Thread[] bArray = new Thread[5];
+        Thread[] cArray = new Thread[5];
+
+        for (int i = 0;i<5;i++){
+            aArray[i] =new Thread(a);
+            bArray[i] =new Thread(b);
+            cArray[i] =new Thread(c);
+
+            aArray[i].start();
+            bArray[i].start();
+            cArray[i].start();
+        }
+
+
+    }
+}
+
+/*
+输出：
+ThreadA 1
+ThreadA 2
+ThreadA 3
+ThreadB 1
+ThreadB 2
+ThreadB 3
+ThreadC 1
+ThreadC 2
+ThreadC 3
+ThreadA 1
+ThreadA 2
+ThreadA 3
+ThreadB 1
+ThreadB 2
+ThreadB 3
+ThreadC 1
+ThreadC 2
+ThreadC 3
+ThreadA 1
+ThreadA 2
+ThreadA 3
+ThreadB 1
+ThreadB 2
+ThreadB 3
+ThreadC 1
+ThreadC 2
+ThreadC 3
+ThreadA 1
+ThreadA 2
+ThreadA 3
+ThreadB 1
+ThreadB 2
+ThreadB 3
+ThreadC 1
+ThreadC 2
+ThreadC 3
+ThreadA 1
+ThreadA 2
+ThreadA 3
+ThreadB 1
+ThreadB 2
+ThreadB 3
+ThreadC 1
+ThreadC 2
+ThreadC 3
+
+ */
diff --git a/java-multithread/src/main/java/com/brianway/learning/java/multithread/lock/example10/Service1.java b/java-multithread/src/main/java/com/brianway/learning/java/multithread/lock/example10/Service1.java
@@ -0,0 +1,30 @@
+package com.brianway.learning.java.multithread.lock.example10;
+
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+
+/**
+ * Created by Brian on 2016/4/15.
+ */
+
+/**
+ * TODO
+ * 这里为什么用双try?
+ * 以前不都是直接try catch finally的吗？
+ */
+public class Service1 {
+    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+
+    public void read(){
+        try {
+            try {
+                lock.readLock().lock();
+                System.out.println("获得读锁"+ Thread.currentThread().getName()+" "+System.currentTimeMillis());
+                Thread.sleep(10000);
+            } finally {
+                lock.readLock().unlock();
+            }
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+}
diff --git a/java-multithread/src/main/java/com/brianway/learning/java/multithread/lock/example10/Service2.java b/java-multithread/src/main/java/com/brianway/learning/java/multithread/lock/example10/Service2.java
@@ -0,0 +1,30 @@
+package com.brianway.learning.java.multithread.lock.example10;
+
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+
+/**
+ * Created by Brian on 2016/4/15.
+ */
+
+/**
+ * TODO
+ * 这里为什么用双try?
+ * 以前不都是直接try catch finally的吗？
+ */
+public class Service2 {
+    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+
+    public void write(){
+        try {
+            try {
+                lock.writeLock().lock();
+                System.out.println("获得写锁"+ Thread.currentThread().getName()+" "+System.currentTimeMillis());
+                Thread.sleep(10000);
+            } finally {
+                lock.writeLock().unlock();
+            }
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+}
diff --git a/java-multithread/src/main/java/com/brianway/learning/java/multithread/lock/example10/Service3.java b/java-multithread/src/main/java/com/brianway/learning/java/multithread/lock/example10/Service3.java
@@ -0,0 +1,44 @@
+package com.brianway.learning.java.multithread.lock.example10;
+
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+
+/**
+ * Created by Brian on 2016/4/15.
+ */
+
+/**
+ * TODO
+ * 这里为什么用双try?
+ * 以前不都是直接try catch finally的吗？
+ */
+public class Service3 {
+    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+
+    public void read(){
+        try {
+            try {
+                lock.readLock().lock();
+                System.out.println("获得读锁 "+ Thread.currentThread().getName()+" "+System.currentTimeMillis());
+                Thread.sleep(10000);
+            } finally {
+                lock.readLock().unlock();
+            }
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public void write(){
+        try {
+            try {
+                lock.writeLock().lock();
+                System.out.println("获得写锁 "+ Thread.currentThread().getName()+" "+System.currentTimeMillis());
+                Thread.sleep(10000);
+            } finally {
+                lock.writeLock().unlock();
+            }
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+}
