教你一文读清synchronized 和 Lock的优缺点(同步锁-JUC)

1.从多维度解析synchronized 和 Lock的区别

1.1.原始构成区别

   ①synchronizezd是关键字属于JVM层面
      monitorenter - 进入
      monitorexit - 离开
底层是通过monitor对象来完成，其实wait/notify等方法也依赖于monitor对象只有在同步块或方法中才能调wait/notify等方法，用javap命令查看字节码会发现，每个synchronized会被自动编译为 一条monitorenter指令 和 两条monitorexit指令，第一条monitorexit指令表示正常退出锁，第二条monitorexit指令表示异常退出锁，保证不会出现死锁的情况
   ②Lock是具体类(java.util.concurrent.locks.Lock)是api层面的锁。

1.2. 使用方法区别

   ①synchronized  不需要用户手动释放锁，当synchronized代码执行完后系统会自动让线程释放对锁的占用。
   ②ReentrantLock 需要用户去手动释放锁，若没有主动释放锁，则该层锁一直被锁住，就又可能导致出现死锁现象。需要lock()和unlock()配合try/finally语句块来使用。

1.3.等待是否可中断

   ①synchronized不可中断，除非抛出异常或者正常运行完成
   ②ReentrantLock 可中断，通过 -设置超时方法tryLock(long timeout TimeUnit unit)；
                                                   -lockInterruptibly()放代码块中，调用interrupt()方法可以中断。

1.4.加锁是否公平

   ①synchronized固定非公平锁
   ②ReentrantLock两者都可以，默认为非公平锁，构造方法可以传入boolean值，true为公平锁，false为非公平锁。

1.5.锁绑定多个条件Condition

   ①synchronized没有
   ②ReentrantLock用来实现分组唤醒线程们，可以精确唤醒，而不是向synchronized要么随机唤醒一个线程要么唤醒全部线程。

2.使用新Lock的好处：代码演示Lock锁绑定多个条件Condition，实现精确唤醒线程

问题背景：多线程之间按顺序调用，实现A->B->C三个线程启动，打印如下效果：
   AA打印1次，BB打印2次，CC打印3次；
   重复上次步骤打印3轮。
问题分析：因为A执行完必须执行B，B执行完必须执行C，此时有严格的顺序关系，可以使用Lock的Condition，进行线程的精确唤醒。

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

// 共享资源类
class ShareResource {
    private int number = 1;// A:1 B:2 C:3
    private Lock lock = new ReentrantLock();
    // 锁线程A
    private Condition c1 = lock.newCondition();
    // 锁线程B
    private Condition c2 = lock.newCondition();
    // 锁线程C
    private Condition c3 = lock.newCondition();

    public void printA() {
        lock.lock();
        try {
            // 多线程为防止虚假唤醒的影响，必须使用while来代替if做判断
            /* 虚假唤醒：一次性唤醒多个在c1阻塞的线程。
               从逻辑上来说，每次只能有一个线程执行打印A，但是因为多个线程都经过了if的判断，
               不会再去判断一次if条件，故导致了出错
             */
            // 1.判断
            while(number != 1) {
                c1.await();
            }
            // 2.业务处理
            System.out.println(Thread.currentThread().getName() + " 被打印");
            // 3.只精准通知2号线程
            number = 2;
            c2.signal();
        } catch (Exception e) {e.printStackTrace();} finally {lock.unlock();}
    }
    public void printB() {
        lock.lock();
        try {
            // 1.判断
            while(number != 2) {
                c2.await();
            }
            // 2.业务处理
            for (int i = 0; i < 2; i++) {
                System.out.println(Thread.currentThread().getName() + " 被打印");
            }
            // 3.只精准通知2号线程
            number = 3;
            c3.signal();
        } catch (Exception e) {e.printStackTrace();} finally {lock.unlock();}
    }
    public void printC() {
        lock.lock();
        try {
            // 1.判断
            while(number != 3) {
                c3.await();
            }
            // 2.业务处理
            for (int i = 0; i < 3; i++) {
                System.out.println(Thread.currentThread().getName() + " 被打印");
            }
            // 3.只精准通知1号线程
            System.out.println("*********当前轮次结束********");
            number = 1;
            c1.signal();

        } catch (Exception e) {e.printStackTrace();} finally {lock.unlock();}
    }
}
// 主方法创建三个线程测试锁
public class SyncAndReentrantLockDemo {
    public static void main(String[] args) {
        ShareResource shareResource = new ShareResource();
        // 创建打印3轮A的线程
        new Thread(() -> {
            for (int i = 0; i < 3; i++) {
                shareResource.printA();
            }
        }, "A").start();
        // 创建打印3轮B的线程
        new Thread(() -> {
            for (int i = 0; i < 3; i++) {
                shareResource.printB();
            }
        }, "B").start();
        // 创建打印3轮C的线程
        new Thread(() -> {
            for (int i = 0; i < 3; i++) {
                shareResource.printC();
            }
        }, "C").start();
    }
}

3.小结：BlockingQueue阻塞队列实现线程通信

    2.0版本的Lock相比1.0版本的synchronized增加了灵活性和多条件锁的功能，但是他们都是通过手动加锁和调用阻塞、唤醒代码来实现线程之间的通信。
    在高并发时代，3.0版本引入了BlockingQueue阻塞队列，此时不需要我们关心阻塞、唤醒线程，这一切将由BlockingQueue一手包办。
可以通过下文详细了解阻塞队列BlockingQueue
一文了解阻塞队列(资源存放地-JUC)
可以通过下文详细了解3.0阶段的并发编程
一文读清线程通信之阻塞队列版