Synchronized和Lock的区别

前言

对象锁（synchronized method{}）和类锁（static sychronized method{}的区别

对象锁也叫实例锁，对应synchronized关键字，当多个线程访问多个实例时，它们互不干扰，每个对象都拥有自己的锁，如果是单例模式下，那么就是变成和类锁一样的功能。

对象锁防止在同一个时刻多个线程访问同一个对象的synchronized块。如果不是同一个对象就没有这样子的限制。

类锁对应的关键字是static sychronized，是一个全局锁，无论多少个对象否共享同一个锁（也可以锁定在该类的class上或者是classloader对象上），同样是保障同一个时刻多个线程同时访问同一个synchronized块，当一个线程在访问时，其他的线程等待。

早期的时候我们对线程的主要操作为：

• synchronized wait notify

然后后面出现了替代方案

• lock await signal

synchronized锁范围

普通方法是实例this，static方法是整个类模板。

代码块：

 public void method1(){synchronized (this) {   //对象锁try {System.out.println("do method1..");Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}}}public void method2(){      //类锁synchronized (ObjectLock.class) {try {System.out.println("do method2..");Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}}}

问题

synchronized 和 lock 有什么区别？用新的lock有什么好处？举例说明

• synchronized 和 lock 有什么区别？用新的lock有什么好处？举例说明

1）synchronized属于JVM层面，属于java的关键字

• monitorenter（底层是通过monitor对象来完成，其实wait/notify等方法也依赖于monitor对象 只能在同步块或者方法中才能调用 wait/ notify等方法）
• Lock是具体类（java.util.concurrent.locks.Lock）是api层面的锁

2）使用方法：

• synchronized：不需要用户去手动释放锁，当synchronized代码执行后，系统会自动让线程释放对锁的占用
• ReentrantLock：则需要用户去手动释放锁，若没有主动释放锁，就有可能出现死锁的现象，需要lock() 和 unlock() 配置try catch语句来完成

3）等待是否中断

• synchronized：不可中断，除非抛出异常或者正常运行完成，2个monitorexit
• ReentrantLock：可中断，可以设置超时方法
  • 设置超时方法，trylock(long timeout, TimeUnit unit)
  • lockInterrupible() 放代码块中，调用interrupt() 方法可以中断rʌpt

4）加锁是否公平

• synchronized：非公平锁
• ReentrantLock：默认非公平锁，构造函数可以传递boolean值，true为公平锁，false为非公平锁

5）锁绑定多个条件Condition

• synchronized：没有，要么随机，要么全部唤醒
• ReentrantLock：用来实现分组唤醒需要唤醒的线程，可以精确唤醒，而不是像synchronized那样，要么随机，要么全部唤醒

举例

针对刚刚提到的区别的第5条，我们有下面这样的一个场景

题目：多线程之间按顺序调用，实现 A-> B -> C 三个线程启动，要求如下：
AA打印5次，BB打印10次，CC打印15次
紧接着
AA打印5次，BB打印10次，CC打印15次
..
来10轮

我们会发现，这样的场景在使用synchronized来完成的话，会非常的困难，但是使用lock就非常方便了

也就是我们需要实现一个链式唤醒的操作

当A线程执行完后，B线程才能执行，然后B线程执行完成后，C线程才执行

首先我们需要创建一个重入锁

// 创建一个重入锁
private Lock lock = new ReentrantLock();

然后定义三个条件，也可以称为锁的钥匙，通过它就可以获取到锁，进入到方法里面

// 这三个相当于备用钥匙
private Condition condition1 = lock.newCondition();
private Condition condition2 = lock.newCondition();
private Condition condition3 = lock.newCondition();

然后开始记住锁的三部曲： 判断 干活 唤醒

这里的判断，为了避免虚假唤醒，一定要采用 while

干活就是把需要的内容，打印出来

唤醒的话，就是修改资源类的值，然后精准唤醒线程进行干活：这里A 唤醒B， B唤醒C，C又唤醒A

    public void print5() {lock.lock();try {// 判断while(number != 1) {// 不等于1，需要等待condition1.await();}// 干活for (int i = 0; i < 5; i++) {System.out.println(Thread.currentThread().getName() + "\t " + number + "\t" + i);}// 唤醒 （干完活后，需要通知B线程执行）number = 2;// 通知2号去干活了condition2.signal();} catch (Exception e) {e.printStackTrace();} finally {lock.unlock();}

完整代码：

/*** Synchronized 和 Lock的区别* @author: wzq* @create: 2020-03-17-10:18*/
class ShareResource {// A 1   B 2   c 3private int number = 1;// 创建一个重入锁private Lock lock = new ReentrantLock();// 这三个相当于备用钥匙private Condition condition1 = lock.newCondition();private Condition condition2 = lock.newCondition();private Condition condition3 = lock.newCondition();public void print5() {lock.lock();try {// 判断while(number != 1) {// 不等于1，需要等待condition1.await();}// 干活for (int i = 0; i < 5; i++) {System.out.println(Thread.currentThread().getName() + "\t " + number + "\t" + i);}// 唤醒 （干完活后，需要通知B线程执行）number = 2;// 通知2号去干活了condition2.signal();} catch (Exception e) {e.printStackTrace();} finally {lock.unlock();}}public void print10() {lock.lock();try {// 判断while(number != 2) {// 不等于1，需要等待condition2.await();}// 干活for (int i = 0; i < 10; i++) {System.out.println(Thread.currentThread().getName() + "\t " + number + "\t" + i);}// 唤醒 （干完活后，需要通知C线程执行）number = 3;// 通知2号去干活了condition3.signal();} catch (Exception e) {e.printStackTrace();} finally {lock.unlock();}}public void print15() {lock.lock();try {// 判断while(number != 3) {// 不等于1，需要等待condition3.await();}// 干活for (int i = 0; i < 15; i++) {System.out.println(Thread.currentThread().getName() + "\t " + number + "\t" + i);}// 唤醒 （干完活后，需要通知C线程执行）number = 1;// 通知1号去干活了condition1.signal();} catch (Exception e) {e.printStackTrace();} finally {lock.unlock();}}
}public class SyncAndReentrantLockDemo {public static void main(String[] args) {ShareResource shareResource = new ShareResource();new Thread(() -> {for (int i = 0; i < 10; i++) {shareResource.print5();}}, "A").start();new Thread(() -> {for (int i = 0; i < 10; i++) {shareResource.print10();}}, "B").start();new Thread(() -> {for (int i = 0; i < 10; i++) {shareResource.print15();}}, "C").start();}
}