一、使用ReentrantLock類

1、ReentrantLock的簡單使用

程式碼示例：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class MyService{
	private Lock lock = new ReentrantLock();
	public void methodA(){
		try{
			lock.lock();
			System.out.println("methodA begin ThreadName=" + Thread.currentThread().getName() + " time=" + System.currentTimeMillis());
			Thread.sleep(5000);
			System.out.println("methodA   end ThreadName=" + Thread.currentThread().getName() + " time=" + System.currentTimeMillis());			
		}catch(InterruptedException e){
			e.printStackTrace();
		}finally{
			lock.unlock();
		}
	}
	public void methodB(){
		try{
			lock.lock();
			System.out.println("methodB begin ThreadName=" + Thread.currentThread().getName() + " time=" + System.currentTimeMillis());
			Thread.sleep(5000);
			System.out.println("methodB   end ThreadName=" + Thread.currentThread().getName() + " time=" + System.currentTimeMillis());			
		}catch(InterruptedException e){
			e.printStackTrace();
		}finally{
			lock.unlock();
		}
	}
}
class ThreadA extends Thread{
	private MyService service;
	public ThreadA(MyService service){
		this.service = service;
	}
	@Override
	public void run(){
		service.methodA();
	}
}
class ThreadB extends Thread{
	private MyService service;
	public ThreadB(MyService service){
		this.service = service;
	}
	@Override
	public void run(){
		service.methodB();
	}
}
public class TestClass{
	public static void main(String[] args){	
		MyService service = new MyService();
		ThreadA a = new ThreadA(service);
		a.setName("A");
		ThreadA aa = new ThreadA(service);
		aa.setName("AA");
		ThreadB b = new ThreadB(service);
		b.setName("B");
		ThreadB bb = new ThreadB(service);
		bb.setName("BB");
		a.start();
		aa.start();
		b.start();
		bb.start();
	}
}
 

2、使用Condition實現等待/通知

關鍵字synchronized與wait()/notify()/notifyAll()方法相結合可以實現等待/通知模式，類ReetrantLock也可以實現同樣的功能，但需要藉助Condition物件。Condition類可以實現多路通知功能，也就是一個Lock物件裡面可以建立多個Condition例項，執行緒物件可以註冊在指定的Condition中，從而可以有選擇性地進行執行緒通知，在排程執行緒上更靈活。

下面是使用多個Condition實現通知部分執行緒：

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class MyService{
	private Lock lock = new ReentrantLock();
	public Condition conditionA = lock.newCondition();
	public Condition conditionB = lock.newCondition();
	public void awaitA(){
		try{
			lock.lock();
			System.out.println("awaitA begin ThreadName=" + Thread.currentThread().getName() + " time=" + System.currentTimeMillis());
			conditionA.await();
			System.out.println("awaitA   end ThreadName=" + Thread.currentThread().getName() + " time=" + System.currentTimeMillis());			
		}catch(InterruptedException e){
			e.printStackTrace();
		}finally{
			lock.unlock();
		}
	}
	public void awaitB(){
		try{
			lock.lock();
			System.out.println("awaitB begin ThreadName=" + Thread.currentThread().getName() + " time=" + System.currentTimeMillis());
			conditionB.await();
			System.out.println("awaitB   end ThreadName=" + Thread.currentThread().getName() + " time=" + System.currentTimeMillis());			
		}catch(InterruptedException e){
			e.printStackTrace();
		}finally{
			lock.unlock();
		}
	}
	public void signalAll_A(){
		try{
			lock.lock();
			System.out.println("signalAll_A ThreadName=" + Thread.currentThread().getName() + " time=" + System.currentTimeMillis());
			conditionA.signalAll();//喚醒所有在conditionA上等待的執行緒
		}finally{
			lock.unlock();
		}
	}
	public void signalAll_B(){
		try{
			lock.lock();
			System.out.println("signalAll_B ThreadName=" + Thread.currentThread().getName() + " time=" + System.currentTimeMillis());
			conditionB.signalAll();//喚醒所有在conditionA上等待的執行緒
		}finally{
			lock.unlock();
		}
	}
}
class ThreadA extends Thread{
	private MyService service;
	public ThreadA(MyService service){
		this.service = service;
	}
	@Override
	public void run(){
		service.awaitA();
	}
}
class ThreadB extends Thread{
	private MyService service;
	public ThreadB(MyService service){
		this.service = service;
	}
	@Override
	public void run(){
		service.awaitB();
	}
}
public class TestClass{
	public static void main(String[] args) throws InterruptedException{	
		MyService service = new MyService();
		ThreadA a = new ThreadA(service);
		a.setName("A");
		ThreadA aa = new ThreadA(service);
		aa.setName("AA");
		ThreadB b = new ThreadB(service);
		b.setName("B");
		ThreadB bb = new ThreadB(service);
		bb.setName("BB");
		a.start();
		aa.start();
		b.start();
		bb.start();
		Thread.sleep(3000);
		service.signalAll_A();
	}
}
 

3、公平鎖與非公平鎖

鎖Lock分為“公平鎖”和“非公平鎖”，公平鎖表示執行緒獲取鎖的順序是按照執行緒加鎖的順序來分配的，即先來先得的FIFO先進先出順序。而非公平鎖就是一種獲得鎖的搶佔機制，是隨機獲得鎖的。建立公平鎖就是在ReentrantLock類的建構函式中傳入true：Lock lock = new ReentrantLock(true);

4、ReentrantLock的幾個方法

（1）getHoldCount()的作用是查詢當前執行緒保持此鎖定的個數，也就是呼叫lock()方法的次數。

（2）getQueueLength()的作用是返回正在等待獲取此鎖定的執行緒估計數。

（3）int getWaitQueueLength(Condition condition)的作用是返回等待與此鎖定相關的給定條件Condition的執行緒估計數。

（4）boolean hasQueuedThread(Thread thread)的作用是查詢指定的執行緒是否正在等待獲取此鎖定。

（5）boolean hasQueuedThreads()的作用是查詢是否有執行緒正在等待獲取此鎖定。

（6）boolean hasWaiters(Condition condition)的作用是查詢是否有執行緒正在等待與此鎖定有關的condition條件。

（7）boolean isFair()的作用是判斷是不是公平鎖。

（8）boolean isHeldByCurrentThread()的作用是查詢當前執行緒是否保持此鎖定。

（9）boolean isLocked()的作用是查詢此鎖定是否由任意執行緒保持。

（10）void lockInterruptibly()的作用是：如果當前執行緒未被中斷，則獲取鎖定，如果已經被中斷則出現異常。

（11）boolean tryLock()的作用是，僅在呼叫時鎖定未被另一個執行緒保持的情況下，才獲取該鎖定。

（12）boolean tryLock(long timeout,TimeUnit unit)的作用是，如果鎖定在給定等待時間內沒有被另一個執行緒保持，且當前執行緒未被中斷，則獲取該鎖定。

二、使用ReentrantReadWriteLock類

類ReentrantLock具有完全互斥排他的效果，即同一時間只有一個執行緒在執行ReentrantLock.lock()方法後面的任務。這樣做雖然保證了例項變數的執行緒安全性，但效率很低。使用讀寫鎖ReentrantReadWriteLock類可以解決這個問題。讀寫鎖表示有兩個鎖，一個是讀操作相關的鎖，也稱為共享鎖；另一個是寫操作相關的鎖，也叫排他鎖。也就是多個讀鎖之間不互斥，讀鎖和寫鎖互斥，寫鎖和寫鎖互斥。

如下是讀鎖和寫鎖的使用示例：

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

class MyService{
	private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
	public void read(){
		try{
			lock.readLock().lock();
			System.out.println("獲得讀鎖  ThreadName=" + Thread.currentThread().getName() + " time=" + System.currentTimeMillis());
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally{
			lock.readLock().unlock();
		}
	}
	public void write(){
		try{
			lock.writeLock().lock();
			System.out.println("獲得寫鎖  ThreadName=" + Thread.currentThread().getName() + " time=" + System.currentTimeMillis());
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally{
			lock.writeLock().unlock();
		}
	}
}
class ThreadA extends Thread{
	private MyService service;
	public ThreadA(MyService service){
		this.service = service;
	}
	@Override
	public void run(){
		service.read();
	}
}
class ThreadB extends Thread{
	private MyService service;
	public ThreadB(MyService service){
		this.service = service;
	}
	@Override
	public void run(){
		service.write();
	}
}
public class TestClass{
	public static void main(String[] args) throws InterruptedException{	
		MyService service = new MyService();
		ThreadA a = new ThreadA(service);
		a.setName("A");
		ThreadB b = new ThreadB(service);
		b.setName("B");
		a.start();
		b.start();		
	}
}