ReentrantLock与synchronized的区别

目录

什么是锁?

synchronized关键字的实现

synchronized修饰实例方法

synchronized修饰静态方法

修饰代码块

synchronized 关键字的补充:

ReentrantLock

实现步骤

ReentrantLock的额外尝试机制

内部结构

二者的相同点和不同点

---

什么是锁?

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

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

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

synchronized关键字的实现

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

1. 修饰实例方法：synchronized修饰实例方法, 则用到的锁，默认为this当前方法调用对象；
2. 修饰静态方法：synchronized修饰静态方法, 则其所用的锁，默认为Class对象；
3. 修饰代码块：synchronized修饰代码块, 则其所用的锁，是某个指定Java对象；

synchronized修饰实例方法

• 使用当前对象this充当锁，完成对当前方法的锁定，只有获取this锁的线程才能访问当前方法；
• 并发过程中，同一时刻，可以有N个线程请求执行方法，但只有一个线程可以持有this锁，才能执行；
• 不同线程，持有的对象，必须相同；

以下是当它修饰实例方法时,两种作用和意义相同的写法:

public class Foo {
 // 关键字加在实例方法的定义上
 public synchronized void doSth1() {
 // 获取this锁，才能执行该方法
 }

 // 关键字加在方法体中的代码块上
 public void doSth2() {
 synchronized(this) {
 // 获取this锁，才能执行该代码块
 }
 }
}

下面是代码案例:

public static void main(String[] args) {
 // 实例化一个对象
 Foo fa = new Foo();
 // 创建不同的线程1
 Thread thread01 = new Thread() {
 public void run() {
 // 使用相同的对象访问synchronized方法
 fa.doSth1();
 }
 };
 // 创建不同的线程2
 Thread thread02 = new Thread() {
 public void run() {
 // 使用相同的对象访问synchronized方法
 fa.doSth1();
 }
 };

 // 启动线程
 thread01.start();
 thread02.start();
}

synchronized修饰静态方法

• 使用当前对象的Class对象充当锁，完成对当前方法的锁定，只有获取Class锁的线程才能访问当前方法；
• 不同线程，持有的对象，可以不同，但必须相同class类型；

下面是正确用法:

public class Foo {
 // 静态方法
 public synchronized static void doSth1() {
 // 获取当前对象的Class对象锁，才能执行该方法
 }
}

 还有一种错误写法: 由于静态方法是属于类的,所以不能通过实例对象调用(个人理解)。

 // 实例方法
 public static void doSth2() {
     synchronized(this.getClass()) {
     }
 }

下面是实现案例:

public static void main(String[] args) {
 // 创建不同的对象(相同类型)
 Foo fa = new Foo();
 Foo fb = new Foo();
 // 创建不同线程1
 Thread thread01 = new Thread() {
 public void run() {
 // 使用不同的对象访问synchronized方法
 fa.doSth1();
 }
 };
 // 创建不同线程2
 Thread thread02 = new Thread() {
 public void run() {
 // 使用不同的对象访问synchronized方法
 fb.doSth1();
 }
 };
 // 启动线程
 thread01.start();
 thread02.start();
}

修饰代码块

可以使用自定义的对象充当锁,前提是各个线程必须使用相同的对象,确保是同一把锁。

synchronized(自定义对象) {
     //临界区
}

synchronized 关键字的补充:

• 当一个线程访问对象的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该对象中的非synchronized(this)同步代码块。
• 在没有加锁的情况下, 所有的线程都可以自由地访问对象中的代码, 而synchronized关键字只是限制了线程对于已经加锁的同步代码块的访问，并不会对其他代码做限制。所以，同步代码块应该越短小越好。
• 父类中synchronized修饰的方法，如果子类没有重写，则该方法仍然是线程安全性；如果子类重写，并且没有使用synchronized修饰，则该方法不是线程安全的；
• 在定义接口方法时，不能使用synchronized关键字；
• 构造方法不能使用synchronized关键字，但可以使用synchronized代码块来进行同步；
• 离开synchronized代码块后，该线程所持有的锁，会自动释放；

ReentrantLock

synchronized关键字虽然已经实现可重入锁，但由于获取时必须一直等待，没有额外的尝试机制。所以，在java.util.concurrent.locks包提供的ReentrantLock用于替代synchronized。顾名思义，ReentrantLock也是可重入锁，它和synchronized一样，一个线程可以多次获取同一个锁。

传统的使用synchronized实现线程安全机制,都是直接使用关键字或是修饰代码块,当我们使用ReentrantLock去实现,是两种不同的用法。

实现步骤

1. ReentrantLock是一个高级处理并发包java.util.concurrent里提供给我们的一个类,所以在使用它的时候我们必须实例化这个类的对象;
2. 然后在想要实现原子性操作的步骤之前,调用该对象的lock()方法,给程序上锁;
3. 因为synchronized是Java语言层面提供的语法，所以我们不需要考虑异常;
4. 但是在使用这个类的时候,我们就得考虑代码块中可能会发生异常,所以为了正确释放锁,我们将代码块放在try块中,把unlock()方法放在finally块中,这样就能保证代码块执行完或是出现异常时总是执行unlock()方法顺利解锁。

public class Counter {
 private final Lock lock = new ReentrantLock();
 private int count;
 public void add(int n) {
 lock.lock();
 try {
     count += n;
 } finally {
     lock.unlock();
         }
     }
}

ReentrantLock的额外尝试机制

synchronized关键字虽然已经实现可重入锁，但由于获取时必须一直等待，没有额外的尝试机制。虽然ReentrantLock也是可重入锁,但是它提供了额外的尝试机制: 它可以尝试获取锁,如果在规定时间内未获取到锁,那么它会做一些额外处理,不会让线程无限的等待下去。

所以，使用ReentrantLock比直接使用synchronized更安全，线程在tryLock()失败的时候不会导致死锁。

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

内部结构

ReentrantLock实现了 Lock接口，Lock接口中定义了 lock()、 unlock()、tryLock()等相关操作。

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

• NonfairSync 类继承了 Sync类，表示采用非公平策略获取锁：每一次都尝试获取锁，不会按照公平等待的原则进行等待，不会让等待时间最久的线程获得锁。
• FairSync类也继承了 Sync类，表示采用公平策略获取锁：当资源空闲时，它总是会先判断 sync队列是否有等待时间更长的线程，如果存在，则将当前线程加入到等待队列的尾部，实现了公平获取原则。

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

public ReentrantLock() {
 // 默认非公平策略
 sync = new NonfairSync();
}

有参构造函数: ReentrantLock(boolean)：可以传递参数确定采用公平策略或者是非公平策略，参数为 true表示公平策略，否则，采用非公平策略。

public ReentrantLock(boolean fair) {
 sync = fair ? new FairSync() : new NonfairSync();
}

二者的相同点和不同点

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

synchronized是非公平锁,无法保证等待时间久的线程可以及时获取锁,而ReentrantLock可以通过构造方法指定为公平锁或非公平锁。