Synchronized和Lock的区别

我们从下列几点来介绍下Synchronized和lock的区别
1.原始构造
synchronized是关键字，属于JVM层面；使用monitorenter和monitorexit（底层是通过monitor对象来完成；其wait/notify等方法也依赖于monitor对象，只有在同步代码块或者同步方法中才能调用wait/notify等方法。
额外提一句：反编译synchronized底层中有一个monitorenter,两个monitorexit,一个monitorexit是正常退出解锁，另外一个是异常情况下解锁；
Lock是具体类（java.util.concurrent.Locks.lock）jdk1.5后新增api层面的锁。

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

 Lock lock = new XxxLock();
 // ...
 lock.lock();
 try {
 doSomething();
 doOthers();
 } finally {
 lock.unlock();
 }
 

3.等待是否可中断
synchronized不可以中断，除非抛出异常或者正常执行完成
ReentrantLock可中断：
1.设置超时方法tryLock(long timeout,TimeUnit unit)
2.lockInterruptibly()放代码块中；调用interrupt()方法可中断

4.加锁是否公平
synchronized非公平锁，ReentrantLock两者都可以，默认公平锁，构造方法可以传入boolean值，true为公平锁，false为非公平锁

5.锁绑定多个条件Condition
synchronized没有
ReentrantLock用来实现分组唤醒相应唤醒的线程，可以精确唤醒，而不是像synchronized要么随机唤醒一个线程要么唤醒全部线程。
说到精准唤醒，我们可以从常见的线程依次打印ABC题目来了解Lock的Condition使用。
题目：线程1打印A 1次，线程2打印B 2次 线程3打印C 3次，依次打印3轮
代码实现：

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

public class TestABC {
    public static void main(String[] args) {
        ABCDemo abcDemo = new ABCDemo();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 3; i++) {
                    abcDemo.printA();
                }
            }
        }, "线程1").start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 3; i++) {
                    abcDemo.printB();
                }
            }
        }, "线程2").start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 3; i++) {
                    abcDemo.printC();
                }
            }
        }, "线程3").start();
    }
}

class ABCDemo {
    private  int i = 1;
    private Lock lock = new ReentrantLock();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();

    public void printA() {

        lock.lock();
        try {
        //注意这里是while判断，防止虚假唤醒
            while (i != 1) {
                condition1.await();
            }
            printStr(1, "A");
            i = 2;
            condition2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void printB() {
        lock.lock();
        try {
            while (i != 2) {
                condition2.await();
            }
            printStr(2, "B");
            i = 3;
            condition3.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }


    public void printC() {
        lock.lock();
        try {
            while (i != 3) {
                condition3.await();
            }
            printStr(3, "C");
            i = 1;
            condition1.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void printStr(int i, String s) {
        for (int j = 0; j < i; j++) {
            System.out.println(Thread.currentThread().getName() +"\t"+ s);
        }
    }
}

运行结果：

线程1	A
线程2	B
线程2	B
线程3	C
线程3	C
线程3	C
线程1	A
线程2	B
线程2	B
线程3	C
线程3	C
线程3	C
线程1	A
线程2	B
线程2	B
线程3	C
线程3	C
线程3	C

这个也是使用Lock的好处，可以精准的唤醒某个线程来操作某件事情