What is the difference between synchronized and lock

subject :synchronized and Lock What's the difference? ? With the new Lock What are the benefits ?  For example
1. Original composition   
synchronized Yes, the keyword belongs to JVW level ,
 monitorenter( The bottom is through monitor Object to complete , Actually wait/notify And so on monitor Objects can only be called in synchronous blocks or methods wait/notify Other methods ,
 lock It's a concrete class (java.util.concurrent.locks.Lock) yes api Level lock
2. Usage method
 synchronized There is no need for the user to release the lock manually , When synchronized After the code is executed, the system will automatically let the thread release the lock occupation
ReentrantLock You need to manually release the lock , If there is no active release lock , May cause Deadlock
3. Whether waiting can be interrupted
synchronized Non interruptible , Unless an exception is thrown or normal operation is completed
ReentrantLock interruptible ,1. No timeout method is set tryLock(long timeout,Timeunit unit)
                2.LockIterruptiblyo Put it in the code block , Tiaochuan interrupt() Method can be interrupted   
4. Is it fair to lock
synchronized Not fair lock
ReentrantLock Either way , Default unfair lock , The constructor can pass in boolean value ,ture Lock for fairness ,false Lock for unfairness
5. Lock binding multiple conditions condition
synchronized No,
ReentrantLock Threads used to wake up packets , Can wake up exactly , Not like it synchronized Either wake up one thread randomly or wake up all threads .
Precise wake-up sample code :
 

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 Judge 
        while (number!=1){
            c1.await();
        }
        //2 work 
          for (int i = 1; i <=1 ; i++) {
              System.out.println(Thread.currentThread().getName()+"\t"+i);
          }
          //3 notice 
          number=2;
          c2.signal(); // Notify the next thread 

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

    public void print2(){
        lock.lock();
        try {
            //1 Judge 
            while (number!=2){
                c2.await();
            }
            //2 work 
            for (int i = 1; i <=2 ; i++) {
                System.out.println(Thread.currentThread().getName()+"\t"+i);
            }
            //3 notice 
            number=3;
            c3.signal(); // Notify the next thread 

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    public void print3(){
        lock.lock();
        try {
            //1  Judge 
            while (number!=3){
                c3.await();
            }
            //2 work 
            for (int i = 1; i <=3 ; i++) {
                System.out.println(Thread.currentThread().getName()+"\t"+i);
            }
            //3 notice 
            number=1;
            c1.signal(); // Notify the next thread 

        }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();
    }
}

//  Execution results 
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