synchronized关键字、ReentrantLock与原子类比较

我们先比较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);
		}
	}
}