浅谈Java并发编程之Lock锁和条件变量

  Lock lock = new ReentrantLock();//默认使用非公平锁，如果要使用公平锁，需要传入参数true
  ........
  lock.lock();
  try {
   //更新对象的状态
   //捕获异常，必要时恢复到原来的不变约束
  //如果有return语句，放在这里
 } finally {
   lock.unlock();  //锁必须在finally块中释放
 }

	ReentrantLock lock = new ReentrantLock();
	...........
	lock.lockInterruptibly();//获取响应中断锁
	try {
	  //更新对象的状态
	  //捕获异常，必要时恢复到原来的不变约束
	  //如果有return语句，放在这里
	}finally{
		lock.unlock();  //锁必须在finally块中释放
	}

public class Buffer {
 
 private Object lock;
 
 public Buffer() {
  lock = this;
 }
 
 public void write() {
  synchronized (lock) {
   long startTime = System.currentTimeMillis();
   System.out.println("开始往这个buff写入数据…");
   for (;;)// 模拟要处理很长时间 
   {
    if (System.currentTimeMillis()
      - startTime > Integer.MAX_VALUE) {
     break;
    }
   }
   System.out.println("终于写完了");
  }
 }
 
 public void read() {
  synchronized (lock) {
   System.out.println("从这个buff读数据");
  }
 }
 
 public static void main(String[] args) {
  Buffer buff = new Buffer();
 
  final Writer writer = new Writer(buff);
  final Reader reader = new Reader(buff);
 
  writer.start();
  reader.start();
 
  new Thread(new Runnable() {
 
   @Override
   public void run() {
    long start = System.currentTimeMillis();
    for (;;) {
     //等5秒钟去中断读 
     if (System.currentTimeMillis()
       - start > 5000) {
      System.out.println("不等了，尝试中断");
      reader.interrupt(); //尝试中断读线程
      break;
     }
 
    }
 
   }
  }).start();
  // 我们期待“读”这个线程能退出等待锁，可是事与愿违，一旦读这个线程发现自己得不到锁，
  // 就一直开始等待了，就算它等死，也得不到锁，因为写线程要21亿秒才能完成 T_T ，即使我们中断它，
  // 它都不来响应下，看来真的要等死了。这个时候，ReentrantLock给了一种机制让我们来响应中断，
  // 让“读”能伸能屈，勇敢放弃对这个锁的等待。我们来改写Buffer这个类，就叫BufferInterruptibly吧，可中断缓存。
 }
}
 
class Writer extends Thread {
 
 private Buffer buff;
 
 public Writer(Buffer buff) {
  this.buff = buff;
 }
 
 @Override
 public void run() {
  buff.write();
 }
}
 
class Reader extends Thread {
 
 private Buffer buff;
 
 public Reader(Buffer buff) {
  this.buff = buff;
 }
 
 @Override
 public void run() {
 
  buff.read();//这里估计会一直阻塞 
 
  System.out.println("读结束");
 
 }
}

import java.util.concurrent.locks.ReentrantLock;
 
public class BufferInterruptibly {
 
 private ReentrantLock lock = new ReentrantLock();
 
 public void write() {
  lock.lock();
  try {
   long startTime = System.currentTimeMillis();
   System.out.println("开始往这个buff写入数据…");
   for (;;)// 模拟要处理很长时间 
   {
    if (System.currentTimeMillis()
      - startTime > Integer.MAX_VALUE) {
     break;
    }
   }
   System.out.println("终于写完了");
  } finally {
   lock.unlock();
  }
 }
 
 public void read() throws InterruptedException {
  lock.lockInterruptibly();// 注意这里，可以响应中断 
  try {
   System.out.println("从这个buff读数据");
  } finally {
   lock.unlock();
  }
 }
 
 public static void main(String args[]) {
  BufferInterruptibly buff = new BufferInterruptibly();
 
  final Writer2 writer = new Writer2(buff);
  final Reader2 reader = new Reader2(buff);
 
  writer.start();
  reader.start();
 
  new Thread(new Runnable() {
 
   @Override
   public void run() {
    long start = System.currentTimeMillis();
    for (;;) {
     if (System.currentTimeMillis()
       - start > 5000) {
      System.out.println("不等了，尝试中断");
      reader.interrupt(); //此处中断读操作
      break;
     }
    }
   }
  }).start();
 
 }
}
 
class Reader2 extends Thread {
 
 private BufferInterruptibly buff;
 
 public Reader2(BufferInterruptibly buff) {
  this.buff = buff;
 }
 
 @Override
 public void run() {
 
  try {
   buff.read();//可以收到中断的异常，从而有效退出 
  } catch (InterruptedException e) {
   System.out.println("我不读了");
  }
 
  System.out.println("读结束");
 
 }
}
 
class Writer2 extends Thread {
 
 private BufferInterruptibly buff;
 
 public Writer2(BufferInterruptibly buff) {
  this.buff = buff;
 }
 
 @Override
 public void run() {
  buff.write();
 }
 
}

import java.util.concurrent.*;
import java.util.concurrent.locks.*;
 
class Info{	// 定义信息类
	private String name = "name";//定义name属性，为了与下面set的name属性区别开
	private String content = "content" ;// 定义content属性，为了与下面set的content属性区别开
	private boolean flag = true ;	// 设置标志位,初始时先生产
	private Lock lock = new ReentrantLock(); 
	private Condition condition = lock.newCondition(); //产生一个Condition对象
	public void set(String name,String content){
		lock.lock();
		try{
			while(!flag){
				condition.await() ;
			}
			this.setName(name) ;	// 设置名称
			Thread.sleep(300) ;
			this.setContent(content) ;	// 设置内容
			flag = false ;	// 改变标志位，表示可以取走
			condition.signal();
		}catch(InterruptedException e){
			e.printStackTrace() ;
		}finally{
			lock.unlock();
		}
	}
 
	public void get(){
		lock.lock();
		try{
			while(flag){
				condition.await() ;
			}	
			Thread.sleep(300) ;
			System.out.println(this.getName() + 
				" --> " + this.getContent()) ;
			flag = true ;	// 改变标志位，表示可以生产
			condition.signal();
		}catch(InterruptedException e){
			e.printStackTrace() ;
		}finally{
			lock.unlock();
		}
	}
 
	public void setName(String name){
		this.name = name ;
	}
	public void setContent(String content){
		this.content = content ;
	}
	public String getName(){
		return this.name ;
	}
	public String getContent(){
		return this.content ;
	}
}
class Producer implements Runnable{	// 通过Runnable实现多线程
	private Info info = null ;		// 保存Info引用
	public Producer(Info info){
		this.info = info ;
	}
	public void run(){
		boolean flag = true ;	// 定义标记位
		for(int i=0;i<10;i++){
			if(flag){
				this.info.set("姓名--1","内容--1") ;	// 设置名称
				flag = false ;
			}else{
				this.info.set("姓名--2","内容--2") ;	// 设置名称
				flag = true ;
			}
		}
	}
}
class Consumer implements Runnable{
	private Info info = null ;
	public Consumer(Info info){
		this.info = info ;
	}
	public void run(){
		for(int i=0;i<10;i++){
			this.info.get() ;
		}
	}
}
public class ThreadCaseDemo{
	public static void main(String args[]){
		Info info = new Info();	// 实例化Info对象
		Producer pro = new Producer(info) ;	// 生产者
		Consumer con = new Consumer(info) ;	// 消费者
		new Thread(pro).start() ;
		//启动了生产者线程后，再启动消费者线程
		try{
			Thread.sleep(500) ;
		}catch(InterruptedException e){
			e.printStackTrace() ;
		}
 
		new Thread(con).start() ;
	}
}

ReadWriteLock rwl = new ReentrantReadWriteLock();	 
rwl.writeLock().lock() //获取写锁
rwl.readLock().lock() //获取读锁