synchronized和Lock有什么区别？用新的lock有什么好处？

1.原始构成
   synchronized是关键字属于JVM层面
   从反编译后的字节码中可以看到
      monitiorenter（底层是通过monitor对象来完成，其实wait/notify等方法也依赖于monitor对象只有在同步代码块或方法中才能调wait/notify等方法）
      monitorexit
   Lock是具体类（java.util.concurrent.locks.Lock）是api层面的锁

2.使用方法
   synchronized不需要用户去手动释放锁，当synchronized代码执行完后系统会自动让线程释放对锁的占用
   ReentrantLock则需要用户去手动释放锁，若没有主动释放锁，就有可能出现死锁现象。
   需要lock()和unlock()方法配合try/finally语句块来完成

3.等待是否可中断
   synchronized不可中断，除非抛出异常或正常运行完成
   ReentrantLock可中断，1.设置超时方法tryLock(long timeout,TimeUint unit)
                        2.lockInterruptibly()放代码块中，调用interrupt()方法可中断
4.加锁是否公平
   synchronized非公平锁
   ReentrantLock两者都可以，默认非公平锁，构造方法可以传入boolean值，true为公平锁，false为非公平锁

5.锁绑定多个条件Condition
   synchronized没有
   ReentrantLock用来实现分组唤醒需要唤醒的线程们，可以精确唤醒，而不是像synchronized要么随机唤醒一个线程，要么唤醒全部线程

第五点的具体演示：
代码：

class ShareReource{

    private int number = 1;
    private Lock lock = new ReentrantLock();
    private Condition c1 = lock.newCondition();
    private Condition c2 = lock.newCondition();
    private Condition c3 = lock.newCondition();

    public void print5(){

        try {
            lock.lock();

            //1.判断
            while (number != 1){
                c1.await();
            }

            //2.干活
            for (int i = 1; i <= 5; i++) {
                System.out.println(Thread.currentThread().getName() + "\t" + i);
            }

            //3.通知
            number = 2;
            c2.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }

    }
    public void print10(){

        try {
            lock.lock();

            //1.判断
            while (number != 2){
                c2.await();
            }

            //2.干活
            for (int i = 1; i <= 10; i++) {
                System.out.println(Thread.currentThread().getName() + "\t" + i);
            }

            //3.通知
            number = 3;
            c3.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }

    }
    public void print15(){

        try {
            lock.lock();

            //1.判断
            while (number != 3){
                c3.await();
            }

            //2.干活
            for (int i = 1; i <= 15; i++) {
                System.out.println(Thread.currentThread().getName() + "\t" + i);
            }

            //3.通知
            number = 1;
            c1.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }

    }



}




public class SyncAndReentrantLockDemo {

    public static void main(String[] args) throws InterruptedException {

        ShareReource shareReource = new ShareReource();

        new Thread(()->{
            for (int i = 1; i <= 10; i++) {
                shareReource.print5();

            }
        },"A").start();

        new Thread(()->{
            for (int i = 1; i <= 10; i++) {
                shareReource.print10();

            }
        },"B").start();

        new Thread(()->{
            for (int i = 1; i <= 10; i++) {
                shareReource.print15();

            }
        },"C").start();

    }
}

 在这里开启三个线程，进入方法先上锁，并且用while循环防止虚假唤醒的情况，然后执行完业务后修改标志位，然后再通知给相应的Condition对象，这样就可以保证精确唤醒哪一个线程了。