浅谈synchronized和ReentrantLock的区别

文章首发于个人博客，欢迎访问关注：https://www.lin2j.tech

本文会简单对比一下

synchronized

关键字和

Lock

的区别，不会讲到底层原理。

synchronized

和

Lock

有什么区别？使用Lock有什么好处，举例说明。

1. 底层结构不同（所属层面

   JVM

   vs

   API

   ）

• synchronized

  是关键字，属于

  JVM

  层面的。

  • monitorenter

    （底层是通过

    monitor

    对象来完成，其实

    await

    和

    notify

    方法都依赖于

    monitor

    对象，

    await

    和

    notify

    只能再同步块或者同步方法调用 ）

  • monitorexit

• Lock

  是具体的类，属于

  API

  层面的锁。

1. 使用方法不同（手动释放和自动释放的区别）

• synchronized

  不需要手动释放锁，当

  synchronized

  代码执行完成以后，系统会自动让线程释放对所得占用。

• ReentrantLock

  则需要用户去手动释放锁，如果没有主动释放锁，就有可能导致出现死锁现象。需要

  lock()

  和

  unlock()

  方法配合

  try/finally

  语句块来完成。

1. 等待是否可中断 （可否中断）

• synchronized

  不可中断，除非抛异常或者正常运行完成。

• ReentrantLock

  可中断：
  • 设置超时方法

    tryLock(long timeout, TimeUnit unit)

    。

  • lockInterruptibly()

    放代码块中，调用

    interrupt()

    方法可中断。

1. 加锁是否公平（公平锁和非公平锁）

• Synchronized

  是非公平锁。

• ReentrantLock

  两者都可以，默认非公平锁，构造方法可以传入

  boolean

  值，

  true

  为公平锁，

  false

  为非公平锁。

1. 锁绑定多个条件（精确唤醒）

• Synchronized

  没有

• ReentrantLock

  用来实现分组唤醒需要唤醒的线程们，可以精确唤醒，而不是像

  synchronized

  ，要么随机唤醒一个线程，要么唤醒全部线程。

  newCondition()

  方法。

ReentrantLock

多条件精确控制线程 Demo

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author linjinjia [email protected]
 * @date 2021/3/30 21:38
 */
public class SyncAndReentrantLockDemo {
    public static void main(String[] args) {
        ShareResource shareResource = new ShareResource();

        new Thread(()->{
            for (int i = 0; i < 3; i++) {
                shareResource.print1();
            }
        }, "AA").start();
        new Thread(()->{
            for (int i = 0; i < 3; i++) {
                shareResource.print2();
            }
        }, "BB").start();
        new Thread(()->{
            for (int i = 0; i < 3; i++) {
                shareResource.print3();
            }
        }, "CC").start();
    }
}

/**
 * 多线程之间按照顺序调用，实现 A->B->C三个线程启动，要求如下：
 * AA 打印 1 次，BB 打印 2次，CC打印 3次
 * 来3轮
 */
class ShareResource {
    /**
     * flag = 1，线程AA启动
     * flag = 2，线程BB启动
     * flag = 3，线程CC启动
     */
    private int flag = 1;
    private Lock lock = new ReentrantLock();
    private Condition c1 = lock.newCondition();
    private Condition c2 = lock.newCondition();
    private Condition c3 = lock.newCondition();

    public void print1(){
        lock.lock();
        try{
            // 1. 判断
            while(flag != 1){
                c1.await();
            }
            // 2. 干活
            print(Thread.currentThread().getName(), 1);
            // 3. 通知
            flag = 2;
            c2.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void print2(){
        lock.lock();
        try{
            // 1. 判断
            while(flag != 2){
                c2.await();
            }
            // 2. 干活
            print(Thread.currentThread().getName(), 2);
            // 3. 通知
            flag = 3;
            c3.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void print3(){
        lock.lock();
        try{
            // 1. 判断
            while(flag != 3){
                c3.await();
            }
            // 2. 干活
            print(Thread.currentThread().getName(), 3);
            // 3. 通知
            flag = 1;
            c1.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    private void print(String name, int count){
        for(int i = 0; i < count; i++){
            System.out.println(name + "\t " + i);
        }
    }
}
           

输出

AA	 0
BB	 0
BB	 1
CC	 0
CC	 1
CC	 2
AA	 0
BB	 0
BB	 1
CC	 0
CC	 1
CC	 2
AA	 0
BB	 0
BB	 1
CC	 0
CC	 1
CC	 2