Synchronized锁和ReentrantLock锁

Java提供了两种锁机制来控制多个线程对共享资源的互斥访问，第一个是JVM实现的synchronized,而另一个是JDK实现的ReentrantLock。

synchronized

1.同步一个代码块

public void func(){
	synchronized(this){
		//...
	}
}

它只作用于同一个对象，如果调用两个对象上的同步代码块，就不会进行同步。

对于一下代码，使用ExecutorService执行了两个线程，由于调用的是同一个对象的同步代码块，因此这两个线程会进行同步，当一个线程进入同步语句块时，另一个线程就必须等待。

public class SynchronizedExample{
	public void func1(){
		synchronized(this){
			for(int i=0; i < 10; i++){
				System.out.print(i + " ");
			}
		}
	}
}

public static void main(String[] args){
	SynchronizedExample e1 = new SynchronizedExample();
	ExecutorServic executorService = Executors.newCachedThreadPool();
	executorService.execute(() -> e1.func1());
	executorService.execute(() -> e1.func1());
}

0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9

对于以下代码，两个线程调用了不同对象的同步代码块，因此这两个线程就不需要同步。从输出结果可以看出，两个线程交叉执行。

public static void main(String[] args){
	SynchronizedExample e1 = new SynchronizedExample();
	SynchronizedExample e2 = new SynchronizedExample();
	ExecutorServic executorService = Executors.newCachedThreadPool();
	executorService.execute(() -> e1.func1());
	executorService.execute(() -> e2.func1());
}

0 0 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9

2.同步一个方法

public synchronized void func(){
	// ...
}

它和同步代码块一样，作用于同一个对象。

3.同步一个类

public void func(){
	synchronized (SynchronizedExample.class){
		// ...	
	}
}

作用于整个类，也就是说两个线程调用同一个类的不同对象上的这种同步语句，也会进行同步。

public class SynchronizedExample{
	public void func2(){
		synchronized (SynchronizedExample.class){
			for(int i = 0; i < 10; i++){
				System.out.print(i + " ");
			}
		}
	}
}

public static void main(String[] args){
	SynchronizedExample e1 = new SynchronizedExample();
	SynchronizedExample e2 = new SynchronizedExample();
	ExecutorServic executorService = Executors.newCachedThreadPool();
	executorService.execute(() -> e1.func2());
	executorService.execute(() -> e2.func2());
}

0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9

4.同步一个静态方法

public synchronized static void fun(){
	// ...
}

作用于整个类。

ReentrantLock

ReentrantLock 是java.until.comcurrent(J.U.C)包中的锁。

public class LockExample{
	private Lock lock = new ReentrantLock();
	public void func(){
		lock.lock();
		try{
			for(int i = 0; i < 10; i++){
				System.out.print(i + " ");
			}
		}finally{
			// 确保释放锁，从而避免发生死锁。
			lock.unlock();
		}
	}

public static void main(String[] args){
	LockExample lockExample = new LockExample();
	ExecutorService executorService = Executors.newCachedThreadPool();
	executorService.execute(() -> lockExample.func());
	executorService.execute(() -> lockExample.func());
}
}

0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9

比较

1.锁的实现

synchronized是JVM实现的，而ReentrantLock是JDK实现的。

2.性能

新版本java对synchronized 进行了很多优化，例如自旋锁等，synchronized 与ReentrantLock大致相同。

3.等待可中断

当持有锁的线程长期不释放锁的时候，正在等待的线程可以选择放弃等待，改为处理其它事情。ReentrantLock 可中断，而synchronized 不行。

4.公平锁

公平锁是指多个线程在等待同一个锁时，必须按照申请锁的时间顺序来依次获得锁。
synchronized 中的锁时非公平的，ReentrantLock 默认情况下也是非公平的，但是也可以是公平的。

5.锁绑定多个条件

一个ReentrantLock 可以同时绑定多个Condition对象。

使用选择

除非需要使用ReentrantLock 的高级功能，否则优先使用synchronized 。这是因为synchronized 是JVM实现的一种锁机制，JVM原生地支持它，而ReentrantLock 不是所有的JDK版本都支持。并且使用synchronized 不用担心没有释放锁而导致死锁问题，因为JVM会确保锁的释放。