Lock lock = new ReentrantLock();//默認使用非公平鎖，如果要使用公平鎖，需要傳入參數true
  ........
  lock.lock();
  try {
   //更新對象的狀態(tài)
   //捕獲異常，必要時恢復到原來的不變約束
  //如果有return語句，放在這里
 } finally {
   lock.unlock();  //鎖必須在finally塊中釋放
 }

	ReentrantLock lock = new ReentrantLock();
	...........
	lock.lockInterruptibly();//獲取響應中斷鎖
	try {
	  //更新對象的狀態(tài)
	  //捕獲異常，必要時恢復到原來的不變約束
	  //如果有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();
  // 我們期待“讀”這個線程能退出等待鎖，可是事與愿違，一旦讀這個線程發(fā)現(xiàn)自己得不到鎖，
  // 就一直開始等待了，就算它等死，也得不到鎖，因為寫線程要21億秒才能完成 T_T ，即使我們中斷它，
  // 它都不來響應下，看來真的要等死了。這個時候，ReentrantLock給了一種機制讓我們來響應中斷，
  // 讓“讀”能伸能屈，勇敢放棄對這個鎖的等待。我們來改寫B(tài)uffer這個類，就叫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屬性區(qū)別開
	private String content = "content" ;// 定義content屬性，為了與下面set的content屬性區(qū)別開
	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實現(xiàn)多線程
	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() //獲取讀鎖