Synchronized与Lock的区别,新的Lock与以前有什么好处

synchronized属于jvm层面，属于java的关键字
Lock是java的API层面的锁，在java.util.concurrent.locks.lock
1.原始构成
synchronized：
monitorenter(底层是通过monitor对象来完成，wait/notify方法都是通过monitor对象来完成，只有在同步代码快里面才能使用wait/notify等方法)
monitorexit
Lock：是具体类
2.使用方法
synchronized不需要手动释放，当线程执行完成之后，系统会自动让线程释放对锁的占用
ReentrantLock需要用户手动去释放锁，如果不及时释放可能出现死锁的状态
lock/unlock配合try/finally使用
3.等待是否中断
synchronized：不可中断，除非抛出异常或者正常完成之后
Lock：可中断，1.设置超时方法tryLock(Long timeout,TimeUtil timeUtil)
2.lockInterruptibly()放在代码块中，调用interrupt()可中断
4.加锁是否公平
synchronized是非公平锁
Lock：默认是非公平锁，也可以变成公平锁，两者都可以
5.锁绑定多个condition
synchronized没有condition
ReentrantLock可以绑定condition，分组唤醒需要的线程们，精准唤醒，而不是想synchronized要么唤醒一个要么唤醒全部。

可中断和condition是Lock独有

多线程的编写流程
1.判断
2.执行
3.通知(可以是唤醒)

condition的signal的唤醒看你们是那个条件的condition

package com.example.demo.Test;

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

/**
 * synchronized与lock的比较
 */
public class SynchronizedCompareLock {
    /**
     * 资源共享类
     *  测试顺序唤醒 1 -> 2 -> 3 ->1
     */
    public static class ShareSource{
        private ReentrantLock reentrantLock = new ReentrantLock();
        //判断当前为什么条件
        private int number = 1;
        //三个执行方法,所以要产生三个条件
        Condition condition1 = reentrantLock.newCondition();
        Condition condition2 = reentrantLock.newCondition();
        Condition condition3 = reentrantLock.newCondition();

        public void print1(){
            reentrantLock.lock();
            try{
                //判断
                while (number!=1){
                    condition1.await();
                }
                //执行
                System.out.println(Thread.currentThread().getName()+":       "+number);
                number = 2;
                //唤醒
                condition1.signal();
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                reentrantLock.unlock();
            }
        }
        public void print2(){
            reentrantLock.lock();
            try{
                //判断
                while (number!= 2){
                    condition2.await();
                }
                //执行
                System.out.println(Thread.currentThread().getName()+":       "+number);
                number = 3;
                //唤醒
                condition2.signal();
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                reentrantLock.unlock();
            }
        }
        public void print3(){
            reentrantLock.lock();
            try{
                //判断
                while (number!=3){
                    condition3.await();
                }
                //执行
                System.out.println(Thread.currentThread().getName()+":       "+number);
                number = 1;
                //唤醒
                condition3.signal();
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                reentrantLock.unlock();
            }
        }

    }

    public static void main(String[] args) throws InterruptedException {
        /**
         * 测试Reentrant的condition 可以分组唤醒需要的线程，精准唤醒线程
         * 线程按顺序调用  A->B->C
         */
        ShareSource shareSource = new ShareSource();
        new Thread(() ->{
            shareSource.print1();
        },"AA").start();
        new Thread(() ->{
            shareSource.print2();
        },"BB").start();
        new Thread(() ->{
            shareSource.print3();
        },"CC").start();
    }
}

monitor：
1.是一种用来实现同步的工具
2.每一个java对象都有一个monitor相对于
3.monitor是synchronized的基础