笔记摘要

这里介绍了java5中的线程锁技术：Lock和Condition，实现线程间的通信，其中的读锁和写锁的使用通过一个缓存系统进行了演示，对于Condition的应用通过一个阻塞队列进行演示。

线程锁技术：Lock & Condition 实现线程同步通信所属包：java.util.concurrent.locks

线程锁 说明
Synchronized 同步方法，锁对象是this；同步静态方法，锁对象是字节码.class；同步代码块，锁对象是任意对象，但必须是同一个对象
Lock 同步锁接口
ReentrantLock lock()，unlock()，newCondition()
ReadWriteLock 读写锁接口
ReentrantReadWriteLock readLock()获取读锁，writeLock()获取写锁
Condition 线程间通信 await()等待 signal()唤醒

1. Lock

Lock比传统线程模型中的synchronized方式更加面向对象，相对于synchronized 方法和语句它具有更广泛的锁定操作，此实现允许更灵活的结构，可以具有差别很大的属性，可以支持多个相关的 Condition 对象。

于现实生活中类似，锁本身也是一个对象。两个线程执行的代码片段要实现同步互斥的结果，它们必须用同一个Lock对象，锁是上在代表要操作的资源的类的内部方法中，而不是线程代码中。

ReentrantLock

方法声明 功能描述
lock() 获取锁
tryLock() 尝试获取锁
unock() 释放锁
newCondition() 获取锁的Condition

常用形式如下

  1. Lock lock = new ReentrantLock();
  3. public void doSth(){
  4.     lock.lock();
  5.     try {
  6.         // 执行某些操作
  7.     }finally {
  8.         lock.unlock();
  9.     }
  10. }

读写锁

分为读锁和写锁，多个读锁不互斥，读锁与写锁互斥，写锁与写锁互斥，这是由JVM自己控制的。你只要上好相应的锁即可。如果你的代码只读数据，可以很多人同时读，但不能同时写，那就上读锁；如果你的代码修改数据，只能有一个人在写，且不能同时读取，那就上写锁。总之，读的时候上读锁，写的时候上写锁！

读写锁的使用情景：

  • 如果代码只读数据，就可以很多人共同读取，但不能同时写。
  • 如果代码修改数据，只能有一个人在写，且不能同时读数据。

API中ReentrantReadWriteLock类提供的一个读写锁缓存示例：

  1. class CachedData {  
  3. 　　Object data;  
  4.     volatile boolean cacheValid;  
  6. 　　ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();  
  8. 　　void processCachedData() {  
  10. 　　      rwl.readLock().lock();  
  12. 　　      if (!cacheValid) {  
  14. 　　      // Must release read lock before acquiring write lock  
  16. 　　      rwl.readLock().unlock();  
  17. 　　      rwl.writeLock().lock();  
  19. 　　     // Recheck state because another thread might have acquired  
  20. 　    　 // write lock and changed state before we did.    
  21. 　　    if (!cacheValid) {  
  23. 　　         data = ...       
  24. 　　         cacheValid = true;  
  26. 　　     }  
  27. 　　    // Downgrade by acquiring read lock before releasing write lock  
  28.              rwl.readLock().lock();  
  30. 　　      rwl.writeLock().unlock(); // Unlock write, still hold read  
  32. 　　    }  
  33. 　　       use(data);  
  34. 　　      rwl.readLock().unlock();  
  36. 　　}  
  37. }

读写锁的应用：编写一个缓存系统

注解：为了避免线程的安全问题，synchronized和ReadWriteLock都可以，synchronized也防止了并发读取，性能较低有一个线程先进去，开始读取数据，进行判断，发现没有数据，其他线程就没有必要进去了，就释放读锁，加上写锁，去查找数据写入，为了避免写入的其他对象等待，再做一次判断，数据写入完成后，释放写锁，上读锁，防止写入，还原原来的状态。

两次判断：第一次为了写入数据，所以释放读锁，上写锁。第二次为了防止阻塞的线程重复写入

  1. import java.util.HashMap;  
  2. import java.util.Map;  
  3. import java.util.concurrent.locks.ReadWriteLock;  
  4. import java.util.concurrent.locks.ReentrantReadWriteLock;  
  6. public class CacheDemo {  
  8.     //定义一个map用于缓存对象  
  9.     private Map<String, Object> cache = new HashMap<String, Object>();  
  11.     //获取一个读写锁对象  
  12.     private ReadWriteLock rwl = new ReentrantReadWriteLock();  
  14.     //带有缓存的获取指定值的方法  
  15.     public  Object getData(String key){  
  16.         rwl.readLock().lock();      //上读锁  
  17.         Object value = null;  
  18.         try{  
  19.             value = cache.get(key); //获取要查询的值     
  20.             if(value == null){  //线程出现安全问题的地方  
  22.                 rwl.readLock().unlock();    //没有数据，释放读锁，上写锁
  23.                 // 多个线程去上写锁，第一个上成功后，其他线程阻塞，第一个线程开始执行下面的代码，最后
  24.                 // 释放写锁后，后面的线程继续上写锁，为了避免后面的线程重复写入，进行二次判断
  25.                 rwl.writeLock().lock();
  26.                 try{  
  27.                     if(value==null){    //二次判断，防止其他线程重复写数据  
  28.                             value = "aaaa"; //实际是去查询数据库  
  29.                     }  
  30.                 }finally{  
  31.                     rwl.writeLock().unlock();   //写完数据，释放写锁  
  32.                 }  
  33.                 rwl.readLock().lock();  //恢复读锁  
  34.             }  
  35.         }finally{  
  36.             rwl.readLock().unlock();    //最终释放读锁  
  37.         }  
  38.         return value;   //返回获取到的值  
  39.     }  
  40. }

虚假唤醒：用while代替if

  1. Lock lock = new ReentrantLock();
  2. try {
  3.     lock.lock();
  4.     //需要加锁的代码
  5. }finally {
  6.     lock.unlock();
  7. }

读写锁测试

  1. public class ReadWriteLockTest {
  2.     public static void main(String[] args) {
  3.         final Queue3 q3 = new Queue3();
  4.         for(int i=0;i<3;i++)
  5.         {
  6.             new Thread(){
  7.                 public void run(){
  8.                     while(true){
  9.                         q3.get();
  10.                     }
  11.                 }
  12.             }.start();
  13.             new Thread(){
  14.                 public void run(){
  15.                     while(true){
  16.                         q3.put(new Random().nextInt(10000));
  17.                     }
  18.                 }
  19.             }.start();
  20.         }
  21.     }
  22. }
  24. class Queue3{
  25.     private Object data = null;
  26. ReadWriteLock rwl = new ReentrantReadWriteLock
  27. ();
  28.     public void get(){
  29.         rwl.readLock().lock();
  30.         try {
  31.             System.out.println(Thread.currentThread().getName() + " be ready to read data!");
  32.             Thread.sleep((long)(Math.random()*1000));
  33.             System.out.println(Thread.currentThread().getName() + "have read data :" + data);
  34.         } catch (InterruptedException e) {
  35.             e.printStackTrace();
  36.         }finally{
  37.             rwl.readLock().unlock();
  38.         }
  39.     }
  41.     public void put(Object data){
  42.         rwl.writeLock().lock();
  43.         try {
  44.             System.out.println(Thread.currentThread().getName() + " be ready to write data!");
  45.             Thread.sleep((long)(Math.random()*1000));
  46.             this.data = data;
  47.             System.out.println(Thread.currentThread().getName() + " have write data: " + data);
  48.         } catch (InterruptedException e) {
  49.             e.printStackTrace();
  50.         }finally{
  51.             rwl.writeLock().unlock();
  52.         }
  53.     }
  54. }
  1. Thread-0 be ready to read data!
  2. Thread-2 be ready to read data!
  3. Thread-4 be ready to read data!
  4. Thread-0have read data :null
  5. Thread-2have read data :null
  6. Thread-4have read data :null
  7. Thread-5 be ready to write data!
  8. Thread-5 have write data: 7975
  9. Thread-5 be ready to write data!
  10. Thread-5 have write data: 9832
  11. Thread-3 be ready to write data!
  12. Thread-3 have write data: 2813
  13. Thread-3 be ready to write data!
  14. Thread-3 have write data: 7998
  15. Thread-1 be ready to write data!
  16. Thread-1 have write data: 6737
  17. Thread-1 be ready to write data!
  18. ...

2. Condition

用于实现线程间的通信，是为了解决Object.wait()、nitify()、notifyAll()难以使用的问题

Condition 将 Object 监视器方法（wait、notify 和 notifyAll）分解成截然不同的对象，以便通过将这些对象与任意 Lock 实现组合使用，为每个对象提供多个等待 set（wait-set）。其中，Lock 替代了 synchronized 方法和语句的使用，Condition 替代了 Object 监视器方法wait和notify的使用

一个锁内部可以有多个Condition，即有多路等待通知，传统的线程机制中一个监视器对象上只能有一路等待和通知，要想实现多路等待和通知，必须嵌套使用多个同步监视器对象。使用一个监视器往往会产生顾此失彼的情况。

在等待 Condition 时，允许发生“虚假唤醒”，这通常作为对基础平台语义的让步。对于大多数应用程序，这带来的实际影响很小，因为 Condition 应该总是在一个循环中被等待，并测试正被等待的状态声明。某个实现可以随意移除可能的虚假唤醒，但建议应用程序程序员总是假定这些虚假唤醒可能发生，因此总是在一个循环中等待。

方法声明 功能描述
await() 线程等待
await(long time, TimeUnit unit) 线程等待特定的时间，超过等待时间则为超时
signal() 随机唤醒某个等待线程
signalAll() 唤醒所有等待中的线程

Condition的应用：阻塞队列（使用了两个监视器）

说明：该应用是 java.util.concurrent.locks包中Condition接口中的示例代码。使用了两个Condition分别用于管理取数据的线程，和存数据的线程，这样就可以明确的唤醒需要的一类线程，如果使用一个Condition，当队列满了之后，唤醒的并不一定就是取数据的线程

  1. class BoundedBuffer {  
  3.   final Lock lock = new ReentrantLock();  
  4.   final Condition notFull  = lock.newCondition();   
  5.   final Condition notEmpty = lock.newCondition();   
  7.   final Object[] items = new Object[100];  
  8.   int putptr, takeptr, count;  
  10.   public void put(Object x) throws InterruptedException {  
  11.     lock.lock();  
  12.     try {  
  13.       while (count == items.length) //循环判断队列是否已存满  
  14.         notFull.await();    //如果队列存满了，则要存入数据的线程等待  
  15.       items[putptr] = x;   
  16.       if (++putptr == items.length) putptr = 0;//当队列放满，指针回到0  
  17.       ++count;      //添加了一个数据  
  18.       notEmpty.signal();    //队列中有数据了，所以就唤醒取数据的线程  
  19.     } finally {  
  20.       lock.unlock();  
  21.     }  
  22.   }  
  24.   public Object take() throws InterruptedException {  
  25.     lock.lock();  
  26.     try {  
  27.       while (count == 0)    //循环判断，队列是否有空位  
  28.         notEmpty.await();   //要取的线程等待  
  29.       Object x = items[takeptr];   
  30.       if (++takeptr == items.length) takeptr = 0;  
  31.       --count;  //取走一个，说明队列有空闲的位置，  
  32.       notFull.signal(); //所以通知存入的线程  
  33.       return x;  
  34.     } finally {  
  35.       lock.unlock();  
  36.     }  
  37.   }   
  38. }

Condition测试

  1. public class ConditionCommunication {
  2.     public static void main(String[] args) {
  3.         final Business business = new Business();
  4.         new Thread(
  5.                 new Runnable() {
  6.                     @Override
  7.                     public void run() {
  8.                         for(int i=1;i<=5;i++){
  9.                             business.sub(i);
  10.                         }
  11.                     }
  12.                 }
  13.         ).start();
  15.         for(int i=1;i<=5;i++){
  16.             business.main(i);
  17.         }
  18.     }
  20.         class Business {
  21.         Lock lock = new ReentrantLock();
  22.         Condition condition = lock.newCondition();
  23.         private boolean bShouldSub = true;
  24.         public  void sub(int i){
  25.             lock.lock();
  26.             try{
  27.                 while(!bShouldSub){
  28.                     try {
  29.                         condition.await();
  30.                     } catch (Exception e) {
  31.                         e.printStackTrace();
  32.                     }
  33.                 }
  34.                 for(int j=1;j<=2;j++){
  35.                   System.out.println("sub thread sequence of " + j + ",loop of " + i);
  36.                 }
  37.                 bShouldSub = false;
  38.                 condition.signal();
  39.             }finally{
  40.                 lock.unlock();
  41.             }
  42.         }
  44.         public  void main(int i){
  45.             lock.lock();
  46.             try{
  47.                 while(bShouldSub){
  48.                     try {
  49.                         condition.await();
  50.                     } catch (Exception e) {
  51.                         e.printStackTrace();
  52.                     }
  53.                 }
  54.                 for(int j=1;j<=4;j++){
  55.                  System.out.println("main thread sequence of " + j + ",loop of " + i);
  56.                 }
  57.                 bShouldSub = true;
  58.                 condition.signal();
  59.             }finally{
  60.                 lock.unlock();
  61.             }
  62.         }
  63.     }
  64. }

输出结果

  1. sub thread sequence of 1,loop of 1
  2. sub thread sequence of 2,loop of 1
  3. main thread sequence of 1,loop of 1
  4. main thread sequence of 2,loop of 1
  5. main thread sequence of 3,loop of 1
  6. main thread sequence of 4,loop of 1
  7. sub thread sequence of 1,loop of 2
  8. sub thread sequence of 2,loop of 2
  9. main thread sequence of 1,loop of 2
  10. main thread sequence of 2,loop of 2
  11. main thread sequence of 3,loop of 2
  12. main thread sequence of 4,loop of 2
  13. sub thread sequence of 1,loop of 3
  14. sub thread sequence of 2,loop of 3
  15. main thread sequence of 1,loop of 3
  16. main thread sequence of 2,loop of 3
  17. main thread sequence of 3,loop of 3
  18. main thread sequence of 4,loop of 3
  19. sub thread sequence of 1,loop of 4
  20. sub thread sequence of 2,loop of 4
  21. main thread sequence of 1,loop of 4
  22. main thread sequence of 2,loop of 4
  23. main thread sequence of 3,loop of 4
  24. main thread sequence of 4,loop of 4
  25. sub thread sequence of 1,loop of 5
  26. sub thread sequence of 2,loop of 5
  27. main thread sequence of 1,loop of 5
  28. main thread sequence of 2,loop of 5
  29. main thread sequence of 3,loop of 5
  30. main thread sequence of 4,loop of 5

使用ReentrantLock和Condition实现一个简单的阻塞队列MyArrayBlockingQueue，如果调用take方法时集合中没有数据，那么调用线程就阻塞；如果调用put方法时，集合数据已满，那么也会引起调用线程阻塞。但是，这两个阻塞的条件时不同的，分别为为notFull和notEmpty

  1. import java.util.concurrent.locks.Condition;
  2. import java.util.concurrent.locks.Lock;
  3. import java.util.concurrent.locks.ReentrantLock;
  5. public class MyArrayBlockingQueue<T> {
  6.     // 数据数组
  7.     private final T[] items;
  8.     // 锁
  9.     private final Lock lock = new ReentrantLock();
  10.     // 队满的条件
  11.     private Condition notFull = lock.newCondition();
  12.     // 队空条件
  13.     private Condition notEmpty = lock.newCondition();
  14.     // 头部索引
  15.     private int head;
  16.     // 尾部索引
  17.     private int tail;
  18.     // 数据的个数
  19.     private int count;
  21.     public MyArrayBlockingQueue(int maxSize) {
  22.         items = (T[]) new Object[maxSize];
  23.     }
  25.     public MyArrayBlockingQueue() {
  26.         this(10);
  27.     }
  29.     public void put(T t) {
  30.         lock.lock();
  31.         try {
  32.             while (count == getCapacity()) {
  33.                 System.out.println("数据已满，等待");
  34.                 notFull.await();
  35.             }
  36.             items[tail] = t;
  37.             if (++tail == getCapacity()) {
  38.                 tail = 0;
  39.             }
  40.             ++count;
  41.             notEmpty.signalAll(); // 唤醒等待数据的线程
  42.         } catch (InterruptedException e) {
  43.             e.printStackTrace();
  44.         } finally {
  45.             lock.unlock();
  46.         }
  47.     }
  49.     public T take() {
  50.         lock.lock();
  51.         try {
  52.             while (count == 0) {
  53.                 System.out.println("还没有数据，请等待");
  54.                 notEmpty.await();
  55.             }
  56.             T ret = items[head];
  57.             items[head] = null;
  58.             if (++head == getCapacity()) {
  59.                 head = 0;
  60.             }
  61.             --count;
  62.             notFull.signalAll(); // 唤醒添加数据的线程
  63.             return ret;
  64.         } catch (InterruptedException e) {
  65.             e.printStackTrace();
  66.         } finally {
  67.             lock.unlock();
  68.         }
  69.         return null;
  70.     }
  72.     public int getCapacity() {
  73.         return items.length;
  74.     }
  76.     public int size() {
  77.         lock.lock();
  78.         try {
  79.             return count;
  80.         } finally {
  81.             lock.unlock();
  82.         }
  83.     }
  85.     public static void main(String[] args) {
  86.         MyArrayBlockingQueue<Integer> aQueue = new MyArrayBlockingQueue<Integer>();
  87.         aQueue.put(3);
  88.         aQueue.put(24);
  89.         for (int i = 0; i < 5; i++) {
  90.             System.out.println(aQueue.take());
  91.         }
  92.     }
  93. }

输出结果

  1. 3
  2. 24
  3. 还没有数据，请等待

3. Condition练习

一共有3个线程，两个子线程先后循环2次，接着主线程循环3次，接着又回到两 个子线程先后循环2次，再回到主线程又循环3次，如此循环5次。

思路：老二先执行，执行完唤醒老三，老三执行完唤醒老大，老大执行完唤醒老二，以此循环，所以定义3个Condition对象和一个执行标识即可

示例出现的问题：两个文件中有同名类的情况

解决方案：可以将一个文件中的那个同名外部类放进类中，但是静态不能创建内部类的实例对象，所以需要加上static，这样两个类的名称就不一样了。 一个是原来的类名，一个是在自己类名前面加上外部类的类名。

  1. import java.util.concurrent.locks.Condition;  
  2. import java.util.concurrent.locks.Lock;  
  3. import java.util.concurrent.locks.ReentrantLock;  
  5. public class ThreeConditionCommunication {  
  6.     public static void main(String[] args){  
  8.         final Business business = new Business();  
  10. 　　       //创建并启动子线程老二  
  11.         new Thread(new Runnable(){  
  12.             @Override  
  13.             public void run() {  
  14.                 for(int i=1;i<=5;i++){  
  15.                     business.sub2(i);  
  16.                 }  
  17.             }  
  18.         }).start();  
  20. 　　     //创建并启动子线程老三  
  21.         new Thread(new Runnable(){  
  22.             @Override  
  23.             public void run() {  
  24.                 for(int i=1;i<=5;i++){  
  25.                     business.sub3(i);  
  26.                 }  
  27.             }  
  28.         }).start();  
  30.             //主线程  
  31.             for(int i=1;i<=5;i++){  
  32.                 business.main(i);  
  33.           }  
  34.        }  
  36.     static class Business{  
  38.         Lock lock = new ReentrantLock();   
  39.         Condition condition1 = lock.newCondition();  
  40.         Condition condition2 = lock.newCondition();  
  41.         Condition condition3 = lock.newCondition();  
  43.         //定义一个变量来决定线程的执行权  
  44.         private int ShouldSub = 1;  
  46.         public  void  sub2(int i){  
  47.             //上锁，不让其他线程执行  
  48.             lock.lock();  
  49.             try{  
  50.             if(ShouldSub != 2){ //如果不该老二执行，就等待  
  51.                 try {  
  52.                     condition2.await();  
  53.                 } catch (InterruptedException e) {  
  54.                     e.printStackTrace();  
  55.                 }  
  56.             }  
  58.             for(int j=1;j<=2;j++){  
  59.                 System.out.println("sub thread sequence of"+i+",loop of "+j);  
  60.             }  
  61.             ShouldSub = 3;  //准备让老三执行  
  62.             condition3.signal();        //唤醒老三  
  63.             }finally{  
  64.                 lock.unlock();  
  65.             }     
  66.         }  
  68.         public  void  sub3(int i){  
  70.             lock.lock();  
  71.             try{  
  72.             if(ShouldSub != 3){  
  73.                 try {  
  74.                     condition3.await();  
  75.                 } catch (InterruptedException e) {  
  76.                     e.printStackTrace();  
  77.                 }  
  78.             }  
  80.             for(int j=1;j<=2;j++){  
  81.                 System.out.println("sub2 thread sequence of"+i+",loop of "+j);  
  82.             }  
  83.                 ShouldSub = 1;  //准备让老大执行  
  84.                 condition1.signal();        //唤醒老大  
  85.             }finally{  
  86.                 lock.unlock();  
  87.             }  
  88.         }  
  90. 　　    //主线程  
  91.         public  void main(int i){  
  93.             lock.lock();  
  94.             try{  
  95.             if(ShouldSub!=1){  
  96.                 try {  
  97.                     condition1.await();  
  98.                 } catch (InterruptedException e) {  
  99.                     e.printStackTrace();  
  100.                 }  
  101.             }  
  102.             for(int j=1;j<=3;j++){  
  103.                 System.out.println("main thread sequence of"+i+", loop of "+j);  
  104.             }     
  105.             ShouldSub = 2;  //准备让老二执行  
  106.             condition2.signal();        //唤醒老二  
  107.             }finally{  
  108.                 lock.unlock();  
  109.             }     
  110.         }     
  111.     }  
  112.    }

输出结果

  1. main thread sequence of1, loop of 1
  2. main thread sequence of1, loop of 2
  3. main thread sequence of1, loop of 3
  4. sub thread sequence of1,loop of 1
  5. sub thread sequence of1,loop of 2
  6. sub2 thread sequence of1,loop of 1
  7. sub2 thread sequence of1,loop of 2
  8. main thread sequence of2, loop of 1
  9. main thread sequence of2, loop of 2
  10. main thread sequence of2, loop of 3
  11. sub thread sequence of2,loop of 1
  12. sub thread sequence of2,loop of 2
  13. sub2 thread sequence of2,loop of 1
  14. sub2 thread sequence of2,loop of 2
  15. main thread sequence of3, loop of 1
  16. main thread sequence of3, loop of 2
  17. main thread sequence of3, loop of 3
  18. sub thread sequence of3,loop of 1
  19. sub thread sequence of3,loop of 2
  20. sub2 thread sequence of3,loop of 1
  21. sub2 thread sequence of3,loop of 2
  22. main thread sequence of4, loop of 1
  23. main thread sequence of4, loop of 2
  24. main thread sequence of4, loop of 3
  25. sub thread sequence of4,loop of 1
  26. sub thread sequence of4,loop of 2
  27. sub2 thread sequence of4,loop of 1
  28. sub2 thread sequence of4,loop of 2
  29. main thread sequence of5, loop of 1
  30. main thread sequence of5, loop of 2
  31. main thread sequence of5, loop of 3
  32. sub thread sequence of5,loop of 1
  33. sub thread sequence of5,loop of 2
  34. sub2 thread sequence of5,loop of 1
  35. sub2 thread sequence of5,loop of 2

4. 多路等待和通知

  1. class BoundedBuffer {
  2.     final Lock lock = new ReentrantLock();
  3.     final Condition notFull  = lock.newCondition();
  4.     final Condition notEmpty = lock.newCondition();
  6.     final Object[] items = new Object[100];
  7.     int putptr, takeptr, count;
  9.     public void put(Object x) throws InterruptedException {
  10.         lock.lock();
  11.         try {
  12.             while (count == items.length)
  13.                 notFull.await();
  14.             items[putptr] = x;
  15.             if (++putptr == items.length) putptr = 0;
  16.             ++count;
  17.             notEmpty.signal();
  18.         } finally {
  19.             lock.unlock();
  20.         }
  21.     }
  23.     public Object take() throws InterruptedException {
  24.         lock.lock();
  25.         try {
  26.             while (count == 0)
  27.                 notEmpty.await();
  28.             Object x = items[takeptr];
  29.             if (++takeptr == items.length) takeptr = 0;
  30.             --count;
  31.             notFull.signal();
  32.             return x;
  33.         } finally {
  34.             lock.unlock();
  35.         }
  36.     }
  37. }