线程应用：（七）Lock & Condition同步通信
一、线程锁：Lock 代替synchronized
Lock的作用类似于传统线程模型中的synchronized，更体现面向对象的思想，两个线程执行的代码片段要实现同步互斥的效果，必须要用同一个Lock对象。
1）ReentrantLock
//用Lock替换synchronized互斥 import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class ThreadTest1 { public static void main(String[] args) { new ThreadTest1().init(); } //起了两个线程，一个一直输出"AAAAAA"，一个一直输出"BBBBBB"，但调用方法的对象是同一个 public void init(){ final Outputer outputer = new Outputer(); new Thread(new Runnable() { @Override public void run() { while(true){ outputer.output("AAAAAA"); } } }).start(); new Thread(new Runnable() { @Override public void run() { while(true){ outputer.output("BBBBBB"); } } }).start(); } } class Outputer { Lock lock = new ReentrantLock(); //这里两个线程调用方法的是同一个对象，所以是用的同一把锁 public void output(String name){ //synchronized (this) { lock.lock(); try{ int len = name.length(); for(int i=0;i<len;i++){ System.out.print(name.charAt(i)); } System.out.println(""); }finally{ lock.unlock(); //无论如何都要释放锁 } //} } }
锁中的代码出现异常可能会出现死锁，最好finally释放锁。
2）读写锁 ReentrantReadWriteLock
分为读锁和写锁，使用读写锁可以提高效率，还能实现互斥。ReentrantLock是互斥锁，一个线程获得后，别的线程无论读写都不允许。
多个读锁不互斥，读锁与写锁互斥，写锁与写锁互斥。
规则：
读中可以有读，
读中不能有写，
写中不能有读，写中不能有写。
只是读的时候不用互斥，用读锁即可，不用synchronized。
/** * 起3个线程不停写，3个线程不停读 */ public class ReadWriteLockTest { public static void main(String[] args) { final Queue q = new Queue(); for(int i=0;i<3;i++){ new Thread(){ @Override public void run() { while(true){ q.get(); } } }.start(); new Thread(){ @Override public void run() { while(true){ q.put(new Random().nextInt(10000));; } } }.start(); } } } /** *读时可以有读，读时不能有写 *写时不能有读，也不能有写。 */ class Queue { private Object data = null; //共享数据，只能有一个线程能写该数据，但可以有多个线程同时读该数据 private ReadWriteLock rw1 = new ReentrantReadWriteLock(); //创建一个读写锁 public void get() { rw1.readLock().lock(); //从读写锁中获得读锁 try { System.out.println(Thread.currentThread().getName() + "开始读数据"); Thread.sleep((long)(Math.random()*1000)); System.out.println(Thread.currentThread().getName() + "已读完数据" + data); } catch (InterruptedException e) { e.printStackTrace(); } finally { rw1.readLock().unlock(); //释放读锁 } } public void put(Object data) { rw1.writeLock().lock(); //获得写锁 try { System.out.println(Thread.currentThread().getName() + "开始写数据"); Thread.sleep((long)(Math.random()*1000)); this.data = data; System.out.println(Thread.currentThread().getName() + "已写数据" + data); } catch (InterruptedException e) { e.printStackTrace(); } finally { rw1.writeLock().unlock(); //释放写锁 } } }
利用读写锁来模拟缓存案例。（结合到单例模式下）
/** * 模拟缓存 * 读和写间、写和写间互斥，又可以并发的读，性能高 */ public class CacheDemo { private Map<String, Object> cache = new HashMap<String, Object>(); private ReadWriteLock rw1 = new ReentrantReadWriteLock(); //读写锁 public Object getData(String key){ rw1.readLock().lock(); //读1，多个读时应该要可以并发，不会造成数据的破坏 Object value = null; try { value = cache.get(key); if(value == null){ //如果缓存中没数据，要重新赋值，要先写锁 rw1.readLock().unlock(); //先释放读1 rw1.writeLock().lock(); //写2，如果有多个线程到这一步，也只有一个能获得写锁 try{ if(value==null){ //赋值前再判断一次 value = "aaa"; //模拟取数据库取数据 } } finally { rw1.writeLock().unlock(); //写2 } rw1.readLock().lock(); //读3 } } finally { rw1.readLock().unlock(); //读3 } return value; } }
二、Condition代替wait/notify实现同步通信
wait、notify必须和synchronized一起用，并且synchronized和wait、notify要用同一个锁对象。Condition可以用来代替wait、notify实现同步通信，Condition是在Lock对象的基础上使用的。
使用Lock、Condition代替wait、notify、synchronized，案例代码如下。
public class ConditionTest { public static void main(String[] args) throws InterruptedException { final Business business = new Business(); new Thread(new Runnable() { @Override public void run() { for(int i=1;i<=50;i++){ //循环50轮 try { business.forSub(i); } catch (InterruptedException e) { e.printStackTrace(); } } } }).start(); for(int i=1;i<=50;i++){ //循环50轮 business.forMain(i); } } } class Business { Lock lock = new ReentrantLock(); //用Lock代替synchronized private boolean subGo = true; Condition condition = lock.newCondition(); //Condition基于锁之上 public void forSub(int i) throws InterruptedException{ lock.lock(); try{ while(!subGo){ //防止虚假唤醒 //this.wait(); condition.await(); //别写成condition.wait();，是有区别的 } for(int j=1;j<=10;j++){ System.out.println("subThread of, 第"+i+"轮, 序列为:"+j); } subGo = false; condition.signal(); //this.notify(); }finally{ lock.unlock(); } } public void forMain(int i) throws InterruptedException{ lock.lock(); try{ while(subGo){ condition.await(); //this.wait(); } for(int j=1;j<=100;j++){ System.out.println("mainThread of, 第"+i+"轮, 序列为:"+j); } subGo = true; condition.signal(); //this.notify(); }finally{ lock.unlock(); } } }
一个锁内部可以有多个Condition，可实现多路等待和唤醒。
只用一个Condition的不足：假如有5个线程用来存馒头，1个线程用来取馒头，当笼屉馒头满的时候，5个存的线程等待，当1个取的线程取了一个馒头后，唤醒了5个存线程中的一个继续存，存完后，本来应该要唤醒取的线程，但如果这里只有1个Condition，就不能进行区分，可能会唤醒另外4个存线程中的一个。
当有三个线程要按顺序交替进行，代码如下。
import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class ThreeConditionTest { public static void main(String[] args) throws InterruptedException { final ConditionBusiness business = new ConditionBusiness(); new Thread(new Runnable() { @Override public void run() { for(int i=1;i<=50;i++){ //循环50轮 try { business.sub2(i); } catch (InterruptedException e) { e.printStackTrace(); } } } }).start(); new Thread(new Runnable() { @Override public void run() { for(int i=1;i<=50;i++){ //循环50轮 try { business.sub3(i); } catch (InterruptedException e) { e.printStackTrace(); } } } }).start(); for(int i=1;i<=50;i++){ //循环50轮 business.forMain(i); } } } //用于三个线程的同步通信，主线程-sub2-sub3的顺序交替进行 class ConditionBusiness { Lock lock = new ReentrantLock(); Condition condition1 = lock.newCondition(); Condition condition2 = lock.newCondition(); Condition condition3 = lock.newCondition(); private int flag = 1; //设定1先走 public void forMain(int i) throws InterruptedException{ lock.lock(); try{ while(flag != 1){ condition1.await(); } for(int j=1;j<=10;j++){ System.out.println("main, 第"+i+"轮, 序列为:"+j); } flag = 2; condition2.signal(); //线程1走完唤醒线程2 }finally{ lock.unlock(); } } public void sub2(int i) throws InterruptedException{ lock.lock(); try{ while(flag != 2){ condition2.await(); } for(int j=1;j<=10;j++){ System.out.println("sub2, 第"+i+"轮, 序列为:"+j); } flag = 3; condition3.signal(); //线程2走完唤醒线程3 }finally{ lock.unlock(); } } public void sub3(int i) throws InterruptedException{ lock.lock(); try{ while(flag != 3){ condition3.await(); } for(int j=1;j<=10;j++){ System.out.println("sub3, 第"+i+"轮, 序列为:"+j); } flag = 1; condition1.signal(); //线程3走完唤醒线程1 }finally{ lock.unlock(); } } }
