多线程09-Lock和Condition
1.概念
Lock比传统线程模型中的synchronized方式更加面向对象，与生活中的锁类似，锁本身也应该是一个对象。两个线程执行的代码片段要实现同步互斥的效果，它们必须用同一个Lock对象。
2.案例
package org.lkl.thread; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class LockFoo { /** * 两个线程打印姓名 */ public static void main(String[] args) { final Outputter out = new Outputter() ; new Thread(new Runnable() { @Override public void run() { while(true){ try { Thread.sleep(200) ; out.print("zhangsan") ; } catch (InterruptedException e) { e.printStackTrace(); } } } }).start(); new Thread(new Runnable() { @Override public void run() { while(true){ try { Thread.sleep(1000) ; out.print("liaokailinliaokailinliaokailinliaokailinliaokailinliaokailin") ; } catch (InterruptedException e) { e.printStackTrace(); } } } }).start(); } } class Outputter{ Lock lock = new ReentrantLock() ; public void print(String name){ lock.lock() ; //加上锁 只有等到操作全完成以后才释放锁 try { if(name!=null){ for(int i = 0 ; i<name.length() ;i++){ System.out.print(name.charAt(i)); } System.out.println(); } }finally { lock.unlock() ;//解锁 一般都在finally中解锁 不过程序是否有异常 最终都要解锁 否则会导致阻塞 } } }
3. 读写锁
读写锁：分为读锁和写锁，多个读锁不互斥，读锁与写锁互斥，这是由jvm自己控制的，你只要上好相应的锁即可。如果你的代码只读数据，可以很多人同时读，但不能同时写，那就上读锁；
如果你的代码修改数据，只能有一个人在写，且不能同时读取，那就上写锁。总之，读的时候上读锁，写的时候上写锁！
package cn.itcast.heima2; 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 Queue3 q3 = new Queue3(); for(int i=0;i<3;i++) { new Thread(){ public void run(){ while(true){ q3.get(); } } }.start(); new Thread(){ public void run(){ while(true){ q3.put(new Random().nextInt(10000)); } } }.start(); } } } class Queue3{ private Object data = null;//共享数据，只能有一个线程能写该数据，但可以有多个线程同时读该数据。 ReadWriteLock rwl = new ReentrantReadWriteLock(); 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(); } } 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. Condition
package org.lkl.thead.foo01; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class ConditionFoo { /** * 子线程先执行10次 然后主线程再执行20次 如此循环50次 */ public static void main(String[] args) { final Business b = new Business() ; //子线程执行50次 for(int i = 1 ;i<=50 ;i++){ final int seq = i ; new Thread(new Runnable() { public void run() { b.sub(seq) ; } }).start() ; } //主线程执行50次 for(int i = 1 ;i<=50 ;i++){ b.main(i) ; } } } class Business{ boolean isSub = true ; Lock lock = new ReentrantLock() ; Condition condition = lock.newCondition() ; //子线程执行10次 public void sub(int j ){ //加lock以后不需要synchronized lock.lock() ; try { while(!isSub){ try { condition.await() ; } catch (InterruptedException e) { e.printStackTrace(); } } for(int i = 1 ;i<=10 ;i++){ System.out.println("sub thread execute times " + i + " loop of "+ j); } isSub = false ; condition.signalAll() ; } finally { lock.unlock() ; } } //主线程执行20次 public void main(int j ){ lock.lock() ; try { while(isSub){ try { condition.await() ; } catch (InterruptedException e) { e.printStackTrace(); } } for(int i = 1 ;i<=20 ;i++){ System.out.println("main thread execute times " + i + " loop of "+ j); } isSub = true ; // condition.signal() ; condition.signalAll() ; }finally { lock.unlock() ; } } }
5. 通过condition实现三个线程之间的通信
package cn.itcast.heima2; import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class ThreeConditionCommunication { /** * @param args */ 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.sub2(i); } } } ).start(); new Thread( new Runnable() { @Override public void run() { for(int i=1;i<=50;i++){ business.sub3(i); } } } ).start(); for(int i=1;i<=50;i++){ business.main(i); } } static class Business { Lock lock = new ReentrantLock(); Condition condition1 = lock.newCondition(); Condition condition2 = lock.newCondition(); Condition condition3 = lock.newCondition(); private int shouldSub = 1; public void sub2(int i){ lock.lock(); try{ while(shouldSub != 2){ try { condition2.await(); } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); } } for(int j=1;j<=10;j++){ System.out.println("sub2 thread sequence of " + j + ",loop of " + i); } shouldSub = 3; condition3.signal(); }finally{ lock.unlock(); } } public void sub3(int i){ lock.lock(); try{ while(shouldSub != 3){ try { condition3.await(); } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); } } for(int j=1;j<=20;j++){ System.out.println("sub3 thread sequence of " + j + ",loop of " + i); } shouldSub = 1; condition1.signal(); }finally{ lock.unlock(); } } public void main(int i){ lock.lock(); try{ while(shouldSub != 1){ try { condition1.await(); } catch (Exception e) { // TODO Auto-generated catch block 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(); } } } }
