ReentrantLock与synchronized的区别

一、synchronized

1、什么是Synchronized同步锁

使用Synchronized关键字将一段代码逻辑，用一把锁给锁起来，只有获得了这把锁的线程才访问。并且同一时刻， 只有一个线程能持有这把锁, 这样就保证了同一时刻只有一个线程能执行被锁住的代码，从而确保代码的线程安全。

2、synchronized 关键字的用法

修饰实例方法：synchronized修饰实例方法, 则用到的锁，默认为this当前方法调用对象。

修饰静态方法：synchronized修饰静态方法, 则其所用的锁，默认为Class对象。

修饰代码块：synchronized修饰代码块, 则其所用的锁，是某个指定Java对象。

synchronized修饰实例方法

使用当前对象this充当锁，完成对当前方法的锁定，只有获取this锁的线程才能访问当前方法。

并发过程中，同一时刻，可以有N个线程请求执行方法，但只有一个线程可以持有this锁，才能执行。

不同的线程，持有的对象必须相同。

// 计数器类
public class Counter1 {
	
	// 用于计数的公共变量
	public static int count = 0;
	
	// 递增
	public void add() {
		synchronized (this) {
			for (int i = 0; i < 10000; i++) {
				Counter1.count += 1;
			}
		}
		
	}
	
	// 递减
	public synchronized void dec() {
		for (int i = 0; i < 10000; i++) {
			Counter1.count -= 1;
		}
	}
}

public class Test1 {
	public static void main(String[] args) throws InterruptedException {
		// 计数器对象
				Counter1 counterOps = new Counter1();
				
				// 用于执行递增的线程
				Thread add = new Thread() {
					@Override
					public void run() {
						// +
						counterOps.add();
					}
				};
				
				// 用于执行递减的线程
				Thread dec = new Thread() {
					public void run() {
						// -
						counterOps.dec();
					}
				};
				
				// 启动
				add.start();
				dec.start();
				
				// 插入至main线程前执行
				add.join();
				dec.join();
				
				// 输出计数器的公共计数变量
				System.out.println(Counter1.count);
	}

}

 synchronized修饰静态方法

使用当前对象的Class对象充当锁，完成对当前方法的锁定，只有获取Class锁的线程才能访问当前方法。

不同的线程持有的对象不同，但是必须要有相同的class类型。

// 计数器类
public class Counter2 {
	// 用于计数的公共变量
	public static int count = 0;
	// 递增
	public synchronized static void add() {
		for (int i = 0; i < 10000; i++) {
			Counter2.count += 1;	
		}	
	}
	// 递减
	public static void dec() {
		synchronized (this.getClass()) {
			for (int i = 0; i < 10000; i++) {
				Counter2.count -= 1;
			}
		}	
	}
}

public class Test2 {
	public static void main(String[] args) throws InterruptedException {
		// 计数器对象
				Counter2 counterOps1 = new Counter2();
				Counter2 counterOps2=new Counter2();
				// 用于执行递增的线程
				Thread add = new Thread() {
					@Override
					public void run() {
						// +
						counterOps1.add();
					}
				};
				
				// 用于执行递减的线程
				Thread dec = new Thread() {
					public void run() {
						// -
						counterOps2.dec();
					}
				};
				
				// 启动
				add.start();
				dec.start();
				
				// 插入至main线程前执行
				add.join();
				dec.join();
				
				// 输出计数器的公共计数变量
				System.out.println(Counter2.count);
	}

}

 synchronized修饰代码块

用指定Java对象充当锁。

public class Counter {	
	// 用于计数的公共变量
	public static int count = 0;
	private final Object lock=new Object();
	
	// 递增
	public void add() {
		synchronized (lock) {
			for (int i = 0; i < 10000; i++) {
				Counter.count += 1;
			}
		}		
	}
	
	// 递减
	public void dec() {
		synchronized (lock) {
			for (int i = 0; i < 10000; i++) {
				Counter.count -= 1;
			}
		}
	}
}

 synchronized可以用在方法和代码块上。

二、ReentrantLock

从Java 5引入，ReentrantLock也是可重入锁，它和synchronized一样，一个线程可以多次获取同一个锁，但是它有额外的尝试机制。

public class Counter1 {
	
	// 用于计数的公共变量
	public static int count = 0;
	private final ReentrantLock lock=new ReentrantLock();
	
	// 递增
	public void add() {
	
		for (int i = 0; i < 10000; i++) {
			lock.lock();
			try {
				Counter1.count += 1;
			}finally {
				lock.unlock();
			}
		}
		
	}
	
	// 递减
	public synchronized void dec() {
		for (int i = 0; i < 10000; i++) {
			lock.lock();
			try {
				Counter1.count -= 1;
			}finally {
				lock.unlock();
			}
		}
	}
}

 ReentrantLock需要先创建锁，通过lock()方法加锁，结束后要在finally中通过unlock()方法释放锁。

ReentrantLock尝试获取锁：

在尝试获取锁时，最多等待一秒，一秒后没有获取到锁，tryLock()返回false，不会无限等待，程序会做额外处理，不会导致死锁。

if (lock.tryLock(1, TimeUnit.SECONDS)) {
    try {
        //代码逻辑
    } finally {
        lock.unlock();
    }
}

 ReentrantLock可以用在代码块上。

 ReentrantLock总共有三个内部类：Sync、NonfairSync、FairSync。

FairSync类继承了 Sync类，表示采用公平策略获取锁：当资源空闲时，它会先判断 sync队列是否有等待时间更长的线程，如果存在，则将当前线程加入到等待队列的尾部，采用先进先出来进行管理，实现了公平获取原则。

NonfairSync 类继承了 Sync类，表示采用非公平策略获取锁：每一次都尝试获取锁，不会按照公平等待的原则进行等待，等待时间最久的线程未必先获得锁。

可以传递参数确定采用公平策略或者是非公平策略，参数为 true表示公平策略，否则，默认采用非公平策略。private final ReentrantLock lock=new ReentrantLock(true);   //当前是公平策略

三、两种锁的相同点和不同点:

	Synchronized	ReentrantLock
锁实现机制	AQS	监视器
获取锁	tryLock()尝试获取锁，更灵活	线程抢占模型
释放锁	unlock()释放锁	自动释放
锁类型	支持公平锁和非公平锁（默认）	非公平锁
可重入性	可重入，允许一个线程多次获取同一个锁