synchronized和Lock区别

synchronized和Lock区别

1. 原始构成 
   - sychronized是关键字属于JVM层面的， 
   - monitorenter、monitorexit（底层是通过monitor对象来完成的，其实wait/notify方法也依赖于monitor对象，只有在同步块或者同步方法中才能调用wait/notify等方法）； 
   - Lock属于具体类（java.util.concurrent.locks.lock）是api层面的锁。
2. 使用方法 
   - synchronized不需要用户手动去释放锁，当synchronized代码执行完成后，系统会自动让线程释放对锁的占用； 
   - ReentrantLock则需要用户手动去释放锁，若没有主动释放锁，就有可能导致出现死锁现象。需要lock()、unlock()方法配合try/finally语句块来完成。
3. 等待是否可中断 
   - synchronized不可中断，除非抛出异常或者正常运行完成； 
   - ReentrantLock可中断: 
   -- 设置超时方法tryLock(long timeout, TimeUnit unit) 
   -- lockInterruptibly()放代码块中，调用interrupt()方法可中断
4. 加锁是否公平 
   - synchronized非公平锁 
   - ReentrantLock两者都可以，默认是非公平锁，构造方法可以传入boolean值，传入的值为true表示公平锁，传入的值为false表示非公平锁。
5. 锁绑定多个条件Condition 
   - synchronized不能绑定多个条件 
   - ReentrantLock用来实现分组需要唤醒的线程们，可以精确唤醒，而不像synchronized那样随便唤醒一个线程或者全部线程。

锁绑定多个条件Condition代码验证

/**
 * 锁绑定多个条件Condition代码验证
 * @Author： 小海
 * @Description:
 * @Date: Create in 20:30 2020-02-01
 */
public class ConditionDemo {
    // A:1 B:2 C:30
    private int num = 1;
    private Lock lock = new ReentrantLock();
    private Condition conditionA = lock.newCondition();
    private Condition conditionB = lock.newCondition();
    private Condition conditionC = lock.newCondition();


    // 循环打印5次
    public void print5(){
        lock.lock();

        try {
            // 判断
            while (num != 1){
                conditionA.await();
            }

            // 执行
            for (int i = 0; i < 5; i++) {
                System.out.println(Thread.currentThread().getName() + "	" + i);
            }

            // 通知
            num = 2 ;
            conditionB.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    // 循环打印10次
    public void print10(){
        lock.lock();

        try {
            // 判断
            while (num != 2){
                conditionB.await();
            }

            // 执行
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + "	" + i);
            }

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

    // 循环打印15次
    public void print15(){
        lock.lock();

        try {
            // 判断
            while (num != 3){
                conditionC.await();
            }

            // 执行
            for (int i = 0; i < 15; i++) {
                System.out.println(Thread.currentThread().getName() + "	" + i);
            }

            // 通知
            num = 1;
            conditionA.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    /**
      * 锁绑定多个条件Condition
      * 题目：多线程之间按顺序执行，实现A->B->C三个线程启动，要求如下：
      *      A打印5次，B打印10次，C打印15次，
      *      紧接着
      *      A打印5次，B打印10次，C打印15次，
      *      循环执行10轮
      */
    public static void main(String[] args) {

        ConditionDemo conditionDemo = new ConditionDemo();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                conditionDemo.print5();
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                conditionDemo.print10();
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                conditionDemo.print15();
            }
        },"C").start();
    }
}