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

原始构成

• synchronized： 是属于JVM层面，它是java的关键字。

monitorebter(底层是通过monitor对象来完成，其实wait/notify等方法也依赖于monitor对象只有在同步块或方法中才能调wait/notfy等方法) monitorexit

• lock：是属于API层面，它是java5以后新发布的一个类。

是具体类java.util.concurrent.locks.Lock

使用方法

• synchronized ：不需要用户去手动释放锁，当synchronized代码执行完后系统会自动让线程释放对锁的占用
• ReentrantLock: 则需要用户去手动释放锁若没有主动释放锁，就有可能导致出现死锁现象。

需要lock()和unlock()方法配合try/finally语句块来完成。

等待是否可中断

• synchronized ：不可中断，除非抛出异常或者正常运行完成
• ReentrantLock：可中断，
  1.设置超时方法 tryLock(Long timeout,TimeUnit unit)
  2.lockInterruptibly()放代码块中，调用interrupt()方法可中断

加锁是否公平

• synchronized ：非公平锁
• ReentrantLock：两者都可以，默认为公平锁，构造方法可以传入boolean值，true为公平锁，false为非公平锁
  

锁绑定多个条件Condition

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

精确唤醒举例

package com.threadTest;

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

/**
 *	题目：多线程之间按顺序调用，实现A->B->C三个线程启动，要求如下
 *	AA打印5此，BB打印10次，CC打印15次
 *	紧接着 
 *  AA打印5此，BB打印10次，CC打印15次
 *  一共10轮
 */
class ShareResource{//资源类
	//A:1  B:2  C:3
	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() {
		lock.lock();
		try {
			//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(); //通知2号线程
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			lock.unlock();
		}
	}
	
	public void print10() {
		lock.lock();
		try {
			//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(); //通知2号线程
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			lock.unlock();
		}
	}
	
	public void print15() {
		lock.lock();
		try {
			//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(); //通知2号线程
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			lock.unlock();
		}
	}

}
public class SyncAndReentrantLockDemo {
	public static void main(String[] args) {
		ShareResource shareResource = new ShareResource();
		
		//A线程 10轮
		new Thread(() ->  {
			for (int i = 1; i <= 10; i++) {
				shareResource.print5();
			}
		},"A").start();
		
		//B线程 10轮
		new Thread(() ->  {
			for (int i = 1; i <= 10; i++) {
				shareResource.print10();
			}
		},"B").start();
		
		//C线程 10轮
		new Thread(() ->  {
			for (int i = 1; i <= 10; i++) {
				shareResource.print15();
				System.out.println("-------------第"+i+"轮结束--------------");
			}
		},"C").start();
	}
}