synchronized和lock有什么区别

题目:synchronized和Lock有什么区别?用新的Lock有什么好处?  举例说说
1. 原始构成  
synchronized是关键字属于JVW层面,
 monitorenter(底层是通过monitor对象来完成，其实wait/notify等方法也依赖于monitor对象只有在同步块或方法中才能调wait/notify等方法,
 lock是具体类(java.util.concurrent.locks.Lock)是api层面的锁
 wait 和 notify为什么在Object类而不是在 Thread 类
  1.不仅仅是普通方法或同步工具，更重要的是它们是 Java 中两个线程之间的通信机制，要确保这个机制对每个对象可用, 那么 Object 类则是的正确声明位置
2.每个对象都可以上锁
为什么Java中 wait 方法需要在 synchronized 的方法中调用？
 1.Java 中 wait()和 notify()会产生竞态条件(一段程序被多个线程执行，线程执行的先后顺序不一致会导致最终的状态（结果）不同，我们就称这段代码有竟态条件)
 2.使用方法
 synchronized不需要用户去手动释放锁，当synchronized代码执行完后系统会自动让线程释放对锁的占用
ReentrantLock则需要用户手动释放锁,若没有主动释放锁,就有可能导致出现 死锁现象
3.等待是否可中断
synchronized不可中断，除非抛出异常或者正常运行完成
ReentrantLock 可中断，1.没置超时方法 tryLock(long timeout，Timeunit unit)
                2.LockIterruptiblyo放代码块中，调川interrupt()方法可中断  
4.加锁是否公平
synchronized非公平锁
ReentrantLock 两者都可以,默认非公平锁,构造方法可以传入boolean值,ture为公平锁,false为非公平锁
5.锁绑定多个条件condition
synchronized没有
ReentrantLock 用来实现分组唤醒的线程们,可以精确唤醒,而不是像synchronized要么随机唤醒一个线程要么全部唤醒.
精确唤醒示例代码:

class MyData{
  private int number=1;  // A B  C
  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 (number!=1){
            c1.await();
        }
        //2干活
          for (int i = 1; i <=1 ; i++) {
              System.out.println(Thread.currentThread().getName()+"\t"+i);
          }
          //3通知
          number=2;
          c2.signal(); //通知下一个线程

      }catch (Exception e){
          e.printStackTrace();
      }finally {
          lock.unlock();
      }
  }

    public void print2(){
        lock.lock();
        try {
            //1判断
            while (number!=2){
                c2.await();
            }
            //2干活
            for (int i = 1; i <=2 ; i++) {
                System.out.println(Thread.currentThread().getName()+"\t"+i);
            }
            //3通知
            number=3;
            c3.signal(); //通知下一个线程

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    public void print3(){
        lock.lock();
        try {
            //1 判断
            while (number!=3){
                c3.await();
            }
            //2干活
            for (int i = 1; i <=3 ; i++) {
                System.out.println(Thread.currentThread().getName()+"\t"+i);
            }
            //3通知
            number=1;
            c1.signal(); //通知下一个线程

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
  public static void main(String[] args) {
        MyData myData=new MyData();
        new Thread(()->{
            for(int i=1;i<=3;i++){
                myData.print1();
            }
        },"A").start();

        new Thread(()->{
            for(int i=1;i<=3;i++){
                myData.print2();
            }
        },"B").start();

        new Thread(()->{
            for(int i=1;i<=3;i++){
                myData.print3();
            }
        },"C").start();
    }
}

// 执行结果
A	1
B	1
B	2
C	1
C	2
C	3
A	1
B	1
B	2
C	1
C	2
C	3
A	1
B	1
B	2
C	1
C	2
C	3