线程高级应用-心得5-java5线程并发库中Lock和Condition实现线程同步通讯

1.Lock相关知识介绍

好比我同时种了几块地的麦子，然后就等待收割。收割时，则是哪块先熟了，先收割哪块。

下面举一个面试题的例子来引出Lock缓存读写锁的案例，一个load（）和get（）方法返回值为空时的情况；load（）的返回值是一个代理对象，而get（）却是一个实实在在的对象；所以当返回对象为空是，get（）返回null，load（）返回一个异常对象；具体分析如下：

一个读写锁的缓存库案例；用上面那道面试题分析则很好理解：

线程阻塞问题：运用多个Condition对象解决

2. Lock接口锁的使用

Lock与synchronized最大区别就是：前者更面向对象；Lock要求程序员手动释放锁，synchronized自动释放

 package com.java5.thread.newSkill;

 //concurrent就是java5新增的线程并发库包
 import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReentrantLock;

 /**
  * Lock接口锁的使用
  *   Lock与synchronized最大区别就是：前者更面向对象；
  *   Lock要求程序员手动释放锁，synchronized自动释放。
  */
 public class LockTest {

     public static void main(String[] args) {
         new LockTest().init();

     }

     // 该方法的作用是：外部类的静态方法不能实例化内部类对象；所以不能直接在外部类的main实例化，要创建一个中介的普通方法
     private void init() {
         final Outputer outputer = new Outputer();
         // 线程1
         new Thread(new Runnable() {

             @Override
             public void run() {
                 while (true) {
                     try {
                         Thread.sleep(10);
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
                     outputer.output("yangkai");
                 }
             }
         }).start();
         // 线程2
         new Thread(new Runnable() {

             @Override
             public void run() {
                 while (true) {
                     try {
                         Thread.sleep(10);
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
                     outputer.output("123456");
                 }
             }
         }).start();
     }

     static class Outputer {
         Lock lock = new ReentrantLock();

         public void output(String name) {
             //上锁
             lock.lock();
             try {
                 for (int i = 0; i < name.length(); i++) {
                     // 读取字符串内一个一个的字符
                     System.out.print(name.charAt(i));
                 }
                 System.out.println();
             } finally {
                 //释放锁；
                 /*这里放到finally里的原因是：万一上锁的这个方法中有异常发生;
                  * 那就不执行释放锁代码了，也就是成死锁了；好比你上厕所晕里面了；
                  * 后面的人等啊等的永远进不去似的
                  */
                 lock.unlock();
             }
         }

     }

     /*
      * 如果不使用线程锁Lock会出现以下情况： yangkai 123456 yangkai 1y2a3n4g5k6 ai
      */
 }
 3、读写锁的案例
 package com.java5.thread.newSkill;

 import java.util.Random;
 import java.util.concurrent.locks.ReadWriteLock;
 import java.util.concurrent.locks.ReentrantReadWriteLock;

 /**
  * 读写锁的案例
  */
 public class ReadWriteLockTest {

     public static void main(String[] args) {

         final Queues queues = new Queues();
         for ( int i = 0; i < 10; i++) {
             final int j = i;
             new Thread() {
                 public void run() {
                     //此处打标记A，下面注释会提到
                     /*if(j<10)*/ while(true){
                         queues.get();
                     }
                 }
             }.start();
             new Thread() {
                 public void run() {
                     /*if(j<10)*/while(true) {
                         queues.put(new Random().nextInt(10000));
                     }
                 }
             }.start();
         }
     }
 }

 class Queues {
     // 共享数据;只能有一个线程能写改数据，但能有多个线程同时读数据
     private Object data = null;
     /*这里如果这么写：
      *   ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
           上面的标记A处，如果用while(true)会一直写不读，但是如果不用while死循环则可以正确执行，
           比如用if(i<10);目前还没找到原因，希望大牛们看到后指点迷津;
          个人猜测：没有用面向接口编程，上锁后，死循环中的内容会无穷之的执行，执行不完不会开锁
     */
     ReadWriteLock rwl = new ReentrantReadWriteLock();

     // 读的方法，用的是读锁readLock()
     public void get() {
         rwl.readLock().lock();
         try {
             System.out.println(Thread.currentThread().getName()
                     + " be ready to read data！");
             Thread.sleep((long) Math.random() * 1000);
             System.out.println(Thread.currentThread().getName()
                     + " have read data:" + data);
         } catch (InterruptedException e) {
             e.printStackTrace();
         } finally {
             rwl.readLock().unlock();
         }
     }

     // 写的方法；用到写的锁：writeLock()
     public void put(Object data) {
         rwl.writeLock().lock();
         try {
             System.out.println(Thread.currentThread().getName()
                     + " be ready to write data！");
             Thread.sleep((long) Math.random() * 1000);
             this.data = data;
             System.out.println(Thread.currentThread().getName()
                     + " have write data:" + data);
         } catch (InterruptedException e) {
             e.printStackTrace();
         } finally {
             rwl.writeLock().unlock();
         }
     }
 }
 4. 缓存系统的模拟编写;读写锁的实际应用价值
 package com.java5.thread.newSkill;

 import java.util.HashMap;
 import java.util.Map;
 import java.util.concurrent.locks.ReadWriteLock;
 import java.util.concurrent.locks.ReentrantReadWriteLock;

 public class CacheDemo {

     /**
      * 缓存系统的模拟编写;读写锁的实际应用价值
      */
     private Map<String, Object> cache = new HashMap<String, Object>();

     public static void main(String[] args) {

     }

     private ReadWriteLock rwl = new ReentrantReadWriteLock();

     public Object getData(String key) {
         //如果客户一来读取value数据，则在客户一进去后上一把读锁；防止其他客户再次进行读，产生并发问题
         rwl.readLock().lock();
         Object value = null;
         try {
             value = cache.get(key);
             if (value == null) {
                 //如果如果读到的值为空则释放读锁，打开写锁，准备给value赋值
                 rwl.readLock().unlock();
                 rwl.writeLock().lock();
                 try {
                     //如果打开写锁还为空，则给value赋值aaa
                     if (value == null) {
                         value = "aaa";  //实际失去queryDB()
                     }
                 } finally {
                     //使用完写锁后关掉
                     rwl.writeLock().unlock();
                 }
                 //释放写锁后，再次打开读锁，供客户读取value的数据
                 rwl.readLock().lock();
             }
         } finally {
             //最后客户一读完后释放掉读锁
             rwl.readLock().unlock();
         }
         return value;
     }
 }
 5.新技术condition案例分析；代替wait（）和notify（）方法
 package com.java5.thread.newSkill;

 import java.util.concurrent.locks.Condition;
 import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReentrantLock;

 /**
  * 面试题： 子线程循环10次，接着主线程循环100次，接着又回到子线程循环10次， 接着再回到主线程又循环100次，如此循环50次，代码如下：
  *
  * 思路： 编写一个业务类，是为了不把自己绕进去，体现代码的的高聚类特性和代码的健壮性，
  * 即共同数据（比如这里的同步锁）或共同算法的若干个方法都可以提到同一个类中编写
  *
  * 注意：wait()和notify（）必须在synchronized关键字内使用；
  * 因为this.watit()中用到的this是synchronized（）括号内的
  * 内容；如果不使用synchronized直接就用wait（）会包状态不对的错误
  */
 public class ConditionCommunication {

     public static void main(String[] args) {
         final Business business = new Business();
         new Thread(new Runnable() {

             @Override
             public void run() {
                 for (int i = 1; i <= 50; i++) {
                     business.sub(i);
                 }
             }
         }).start();

         for (int i = 1; i <= 50; i++) {
             business.main(i);
         }

     }
 }

 // 编写一个有子方法（用来调用子线程）和主方法（调用主线程）的业务类

 class Business {
     private boolean bShouldSub = true;
     Lock lock = new ReentrantLock();
     // condition必须基于lock锁之上的
     Condition condition = lock.newCondition();

     public void sub(int i) {
         try {
             lock.lock();
             while (!bShouldSub) {
                 try {
                     // this.wait();
                     /*
                      * condition使用的是await（）注意与wait（）的区别；
                      * 因为condition也是Object对象所以也可以调用wait()方法，所以千万别调错了
                      */
                     condition.await();
                 } catch (Exception e) {
                     e.printStackTrace();
                 }
             }
             for (int j = 1; j <= 10; j++) {
                 System.out.println("sub thread sequence of  " + j
                         + " ,loop of  " + i);
             }
             bShouldSub = false;
             // this.notify();
             condition.signal();
         } finally {
             lock.unlock();
         }
     }

     public void main(int i) {
         /*
          * 这里最好用while，但是跟if的效果一样，只是前者代码更健壮， while可以防止线程自己唤醒自己，即通常所说的伪唤醒；
          * 相当于一个人做梦不是被别人叫醒而是自己做噩梦突然惊醒； 这时用while可以防止这种情况发生
          */
         try {
             lock.lock();
             while (bShouldSub) {
                 try {
                     // this.wait();
                     condition.await();
                 } catch (Exception e) {
                     e.printStackTrace();
                 }
             }
             for (int j = 1; j <= 100; j++) {
                 System.out.println("main thread sequence of  " + j
                         + " ,loop of  " + i);
             }
             bShouldSub = true;
             // this.notify();
             condition.signal();
         } finally {
             lock.unlock();
         }
     }
 }
 6. 多个Condition的应用场景；以下是三个condition通讯的代码：
 package com.java5.thread.newSkill;

 import java.util.concurrent.locks.Condition;
 import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReentrantLock;

 /**
  * 多个Condition的应用场景
  * 以下是三个condition通讯的代码：
  */
 public class ThreeConditionCommunication {

     public static void main(String[] args) {
         final Business business = new Business();
         //线程2，老二线程
         new Thread(new Runnable() {

             @Override
             public void run() {
                 for (int i = 1; i <= 50; i++) {
                     business.sub(i);
                 }
             }
         }).start();

         //线程3，老三线程
         new Thread(new Runnable() {

             @Override
             public void run() {
                 for (int i = 1; i <= 50; i++) {
                     business.sub2(i);
                 }
             }
         }).start();

         //主线程1，老大线程
         for (int i = 1; i <= 50; i++) {
             business.main(i);
         }

     }

     /*编写一个有子方法（用来调用子线程）和主方法（调用主线程）的业务类
      * 这个项目下虽然有两个Business类；但是在不同包下所以不影响； 如果在同一包下，那么就要改名或者将其弄成内部类，如果又想要把他当外部类使用，
      * 那么将其弄成static 静态的就可以了
      */
     static class Business {
         private int shouldSub = 1;
         Lock lock = new ReentrantLock();

         Condition condition1 = lock.newCondition();
         Condition condition2 = lock.newCondition();
         Condition condition3 = lock.newCondition();

         public void sub(int i) {
             try {
                 lock.lock();
                 while (shouldSub != 2) {
                     try {
                         condition2.await();
                     } catch (Exception e) {
                         e.printStackTrace();
                     }
                 }
                 for (int j = 1; j <= 10; j++) {
                     System.out.println("sub thread sequence of  " + j
                             + " ,loop of  " + i);
                 }
                 shouldSub = 3;
                 condition3.signal();
             } finally {
                 lock.unlock();
             }
         }
         public void sub2(int i) {
             try {
                 lock.lock();
                 while (shouldSub != 3) {
                     try {
                         condition3.await();
                     } catch (Exception e) {
                         e.printStackTrace();
                     }
                 }
                 for (int j = 1; j <= 10; j++) {
                     System.out.println("sub2 thread sequence of  " + j
                             + " ,loop of  " + i);
                 }
                 shouldSub = 1;
                 condition1.signal();
             } finally {
                 lock.unlock();
             }
         }

         public void main(int i) {
             try {
                 lock.lock();
                 while (shouldSub != 1) {
                     try {;
                         condition1.await();
                     } catch (Exception e) {
                         e.printStackTrace();
                     }
                 }
                 for (int j = 1; j <= 100; j++) {
                     System.out.println("main thread sequence of  " + j
                             + " ,loop of  " + i);
                 }
                 shouldSub = 2;
                 condition2.signal();
             } finally {
                 lock.unlock();
             }
         }
     }
 }