我們先比較ReentrantLock與synchronized的用法 1、ReentrantLock擁有synchronized相同的併發性和記憶體語義，此外還多了鎖投票，定時鎖等候和中斷等候。執行緒A和B都要獲取物件O的鎖定，假設A獲取了物件O鎖，B將等待A釋放對O的鎖定。
使用synchronized時，如果A不釋放，B將一直等待下去，無法中斷。
使用ReentrantLock時，如果A不釋放，B可以在等待足夠長時間後，停止等待，繼續執行其他事務。 ReentrantLock獲取鎖定的三種方式：
lock()，如果獲取了鎖立即返回，如果別的執行緒持有鎖，當前執行緒則一直處於休眠狀態，直至獲取鎖。
tryLock()，如果獲取了鎖立即返回true，如果別的執行緒下持有，立即返回false;
tryLock(long timeout, TimeUnit unit)，如果獲取了鎖定立即返回true，如果別的執行緒正持有鎖，將等待引數給定的時間，在等待的過程中，如果獲取了鎖定，返回true，如果等待超時，返回false，所以lock()方法相當trylock傳遞個無限大的時間引數;
lockInteruptibly，如果獲取了鎖定立即返回，反之，當前執行緒處理休眠，直至獲取鎖，或者當前執行緒執行緒被其他執行緒中斷。 2、synchronized是在JVM層面實現，不但可以通過一些監控工具監控鎖定，而且在程式碼執行出現異常，JVM自動釋放鎖定;
Lock是通過程式碼實現，為了保證鎖定一定會被釋放，一般會將unLock()放到flyinal{}中。 3、在資源競爭不激烈的情況下，synchronized的效能要優於ReentrantLock，但在資源競爭很激烈的情況下，synchronized的效能會下降幾十倍（jvm需要分配額外的cpu和記憶體來管理同步），但是ReentrantLock的效能能維持常態。 ReentrantLock例子如下：

package test.lock;

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

public class LockTest1 extends Thread {

	private int threadNo;
	private static Lock lock = new ReentrantLock();

	public LockTest1(int threadNo) {
		this.threadNo = threadNo;
	}

	public static void main(String[] args) throws InterruptedException {
		for (int i = 0; i < 10; i++) {
			new LockTest1(i).start();
		}
	}

	@Override
	public void run() {
		lock.lock();
		try {
			for (int i = 0; i < 100; i++) {
				System.out.println("No." + (threadNo + 1) + ": " + (i + 1));
			}
		} finally {
			lock.unlock();
		}
	}
}
 

下面討論原子類： synchronized關鍵字、Lock可以控制程式片段的同步，原子類只能保證單個變數的同步。執行緒競爭不激烈時，原子類效能比synchronized略低，當競爭激烈時，也能維持常態。 下面是一個多執行緒共同計數的程式碼程式碼。

package test.lock;


public class LockTest2 extends Thread {

	private static int race = 0;
	private int threadNo;

	public LockTest2(int threadNo) {
		this.threadNo = threadNo;
	}

	public static void main(String[] args) throws InterruptedException {
		for (int i = 0; i < 10; i++) {
			new LockTest2(i).start();
		}

		while (Thread.activeCount() > 1) {
			Thread.yield();
		}
		System.out.println(race);
	}

	@Override
	public void run() {
		for (int i = 0; i < 1000; i++) {
			race++;
		}
	}
}
 

上面程式執行後，並沒有得到期望的原子類。我們用ActomicInteger實現程式碼如下：

package test.lock;

import java.util.concurrent.atomic.AtomicInteger;

public class LockTest2 extends Thread {

	private static AtomicInteger race = new AtomicInteger();
	private int threadNo;

	public LockTest2(int threadNo) {
		this.threadNo = threadNo;
	}

	public static void main(String[] args) throws InterruptedException {
		for (int i = 0; i < 10; i++) {
			new LockTest2(i).start();
		}

		while (Thread.activeCount() > 1) {
			Thread.yield();
		}
		System.out.println(race);
	}

	@Override
	public void run() {
		for (int i = 0; i < 1000; i++) {
			race.addAndGet(1);
		}
	}
}