ReentrantLock与synchronized的区别

在多线程中，我们不可避免的要使用锁来实现同步，来保证代码的原子性

synchronized同步锁

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

        每个 Java 对象都可以充当一个实现同步的锁，这些锁被称为内置锁或者监视器锁( Monitor Lock )。

synchronized(reference-to-lock) {
 //临界区
}

        其中, 括号里面的 reference-to-lock 就是锁的引用, 任何一个Java对象都可以成为 reference-to-lock 。你可以实例化一个Object对象，将它作为锁。如果直接使用this ，代表使用当前对象作为锁。

synchronized的用法

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

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

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

synchronized修饰实例方法

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

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

        3、不同线程，持有的对象，必须相同；

案例：计数器

import java.util.concurrent.atomic.AtomicInteger;

public class Counter {
	public static int count = 0;

	
	public synchronized void add() {
		for (int i = 0; i <= 10000; i++) {
			count += 1；
		}
	}

	public synchronized void dec() {
		for (int i = 0; i <= 10000; i++) {
			count -= 1；
		}
	}
}

定义测试类

public class Test {
	public static void main(String[] args) throws InterruptedException {

		Counter counter = new Counter();

		Thread th1 = new Thread() {
			@Override
			public void run() {
				counter.add();
			}
		};

		Thread th2 = new Thread() {
			@Override
			public void run() {
				counter.dec();
			}
		};

		th1.start();
		th2.start();

		th1.join();
		th2.join();

		System.out.println(Counter.count);
	}
}

输出结果为0

synchronized关键字补充

1、当一个线程访问对象的一个 synchronized(this) 同步代码块时，另一 个线程仍然可以访问该对象中的非 synchronized(this) 同步代码块。

在没有加锁的情况下, 所有的线程都可以自由地访问对象中的代码, 而 synchronized关键字只是限制了线程对于已经加锁的同步代码块的访问， 并不会对其他代码做限制。所以，同步代码块应该越短小越好。

2、父类中synchronized修饰的方法，如果子类没有重写，则该方法仍然是线程安全性；如果子类重写，并且没有使用synchronized修饰，则该方法不是线程安全的；

3、在定义接口方法时，不能使用synchronized关键字；

4、构造方法不能使用synchronized关键字，但可以使用 synchronized代码块来进行同步；

5、离开synchronized代码块后，该线程所持有的锁，会自动释放；

ReentrantLock锁

        从 Java 5 开始，引入了一个高级处理并发 java.util.concurrent 包，它提供了大量更高 级的并发功能，能大大简化多线程程序的编写。 synchronized 关键字虽然已经实现可重入锁，但由于获取时必须一直等待，没有额外的尝试机制。所以，在 java.util.concurrent.locks 包提供的 ReentrantLock 用于替代 synchroni zed 。顾名思义， ReentrantLock 也是可重入锁，它和 synchronized 一样，一个线程可以多次获取同一个锁。

案例：计数器

import java.util.concurrent.locks.ReentrantLock;

public class Counter {

	public static int count = 0;

	// 创建锁
	private final ReentrantLock lock = new ReentrantLock();

	public void add() {
		for (int i = 0; i <= 10000; i++) {
			lock.lock();
			try {
				Counter.count += 1;
			} finally {
				lock.unlock();
			}
		}
	}

	public void dec() {
		for (int i = 0; i <= 10000; i++) {
			lock.lock();
			try {
				Counter.count -= 1;
			} finally {
				lock.unlock();
			}
		}
	}
}

定义测试类

public class Test01 {
	public static void main(String[] args) throws InterruptedException {

		Counter counter = new Counter();

		Thread th1 = new Thread() {
			@Override
			public void run() {
				counter.add();
			}
		};

		Thread th2 = new Thread() {
			@Override
			public void run() {
				counter.dec();
			}
		};

		th1.start();
		th2.start();

		th1.join();
		th2.join();

		System.out.println(Counter.count);
	}
}

        因为synchronized是 Java 语言层面提供的语法，所以我们不需要考虑异常，而 Reentr antLock是JavaSE核心类库的并发包给我们提供的的可重入锁，所以，在编程过程中，我们就必须先创建锁，结束后在 finally 中正确释放锁。

和 synchronized 不同的是， ReentrantLock 可以尝试获取锁：

if (lock.tryLock(1, TimeUnit.SECONDS)) {
 try {
 ...
 } finally {
 lock.unlock();
 }
}

         上述代码在尝试获取锁的时候，最多等待1秒。如果1秒后仍未获取到锁， tryLock () 返回 false ，程序就可以做一些额外处理，而不是无限等待下去。 所以，使用 ReentrantLock 比直接使用 synchronized 更安全，线程在 tryLock() 失败的时候不会导致死锁。

ReentrantLock内部结构

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

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

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

ReentrantLock 构造函数：默认是采用的非公平策略获取锁。

ReentrantLock 和 Synchronized的区别

	ReentrantLock	Synchronized
锁实现机制	AQS	监视器Monitor
获取锁	可以通过tryLock()尝试获取锁，更灵活	线程抢占模型
释放锁	必须显示通过unlock()释放锁	自动释放
锁类型	支持公平锁和非公平锁	非公平锁
可重入性	可重入	可重入