写这篇文章之前，我去百度了一下啥叫锁，百度百科上写道：置于可启闭的器物上，以钥匙或暗码开启。确实我们一般理解的锁就是门锁，密码锁，但是在计算机科学中，锁又是啥，说实话，这个问题我也思考了很久，也没法很好的用一两句话就让人听得明白，也不想有人看到我的文章，然后将我的结论当作答案，我觉得最好的答案还是在探索的过程中得到的，接下来我们就好好探索一番。

作为一名java程序员，最开始接触到的锁就是synchronized，书本上是这么写的，老师也是这么说的，至于为啥叫锁，可能也没多少人真的去思考过。不知道有没有同学和我一样，经历过只知道用synchronized，后来逐渐的了解ReentrantLock,读写锁，然后又了解了aqs,后来通过百度google,看一些博客(这个我要吐槽一下，在学习过程中遇到过很多文章写的有问题的，反而误导了我)，后面看了看synchronized的源码，最后对比synchronized和ReentrantLock才加深了对锁的一些认知(说实话，作为一个刚毕业3年的非科班出身码农，我也不敢保证自己写的就一定对，算是学习过程中的一些感悟吧)，那接下来我就按照学习顺序来逐渐展开。

先来一段简单的synchronized使用代码：

public static voidmain(String[] args) {

String s= newString();synchronized(s) {

TestJni jni= newTestJni();

jni.jniHello();

}

}

上面代码做的事情很简单，如下图所示，有A B C D E多个线程同时来到synchronized包含的代码块，A先一步进来了，那么BCDE都得等，等我A执行完他们才能进来执行。

       

synchronized用起来确实很简单,我们也可以放在方法上，但是其本质还是锁的对象，这个我们后面分析源码一看就知道了。

随着开发时间越长，synchronized在有些复杂场景下(如需要可中断，可控制时间抢锁，需要多个等待队列分别控制，读写锁等场景的时候)无法满足我们的需求，那么就要用到Lock,下面我们先介绍一下Lock的简单使用：

Lock lock = newReentrantLock();

lock.lock();try{

System.out.println("线程："+Thread.currentThread().getName()+ " 进来啦");

}finally{

lock.unlock();

}

上面是一种最简单的使用，和synchronized作用是一样的,不过加锁之后必须要解锁，且必须紧跟try - finally块解锁，使用起来稍微复杂一点，容易出错。

我们再介绍一种可中断的使用方式：

public static voidmain(String[] args) {

Thread thread= new Thread(() ->{try{

lock.lockInterruptibly();try{

testLock();

}finally{

lock.unlock();

}

}catch(Exception e){

}

});

thread.start();

thread.interrupt();

}public static voidtestLock(){

condition.signalAll();

System.out.println("线程："+Thread.currentThread().getName()+ " 进来啦");

}

这种方式呢，在拿锁被park住了，如果刚好这时候被打断了，就会响应打断退出抢锁并抛出异常，至于捕获到异常开发者怎么做，那就得根据业务来分别处理了。

而像可控制时间的其实就要稍微复杂一点，先看一下synchronized中的使用：

static TestHash s = newTestHash();public static voidmain(String[] args) {

Thread thread1= new Thread(()->{

testLock();

});

Thread thread2= new Thread(()->{synchronized(s) {try{

TimeUnit.SECONDS.sleep(1);

}catch(InterruptedException e) {

}

s.notify();

testLock();

}

});

thread1.start();

thread2.start();

}public static voidtestLock(){synchronized(s) {

System.out.println("线程："+Thread.currentThread().getName()+ " 进来啦");try{

s.wait();

System.out.println("线程："+Thread.currentThread().getName()+ " 叫醒啦");

}catch(InterruptedException e) {

System.out.println("抛异常啦");

}

}

}

这个例子看着要比前面几个复杂一点，首先thread1会进入testLock方法，并拿到锁，thread2等了1秒叫醒thread1(这里就是简单的wait/notify的使用)，然后在拿到锁的情况下，再次进入testLock方法并拿到锁，由于没人唤醒了，会一直卡在这里(这里证明了synchronized的可重入),结果我就不贴了，感兴趣的可以拿着代码去试。

而ReentrantLock的使用也差不多，就是提前用lock去new一个Condition:

static ReentrantLock lock = newReentrantLock();static Condition condition =lock.newCondition();public static voidmain(String[] args) {

Thread thread1= new Thread(()->{

testWaitSingal();

},"thread1");

Thread thread2= new Thread(()->{

lock.lock();try{

TimeUnit.SECONDS.sleep(1);

condition.signal();

testWaitSingal();

}catch(InterruptedException e) {

}finally{

lock.unlock();

}

},"thread2");

thread1.start();

thread2.start();

}public static voidtestWaitSingal(){

lock.lock();try{

System.out.println("线程："+Thread.currentThread().getName()+ " 进来啦");

condition.await();

System.out.println("线程："+Thread.currentThread().getName()+ " 叫醒啦");

}catch(InterruptedException e) {

System.out.println("抛异常啦");

}finally{

lock.unlock();

}

}

可以看到两种用法基本上是一致的，也就是将synchronized换成了lock,wait换成await,notify换成singal,

总结:

基本上我们平时用到的synchronized关键字的用法也就这些，但lock锁不一样，它还支持如上述的中断，更复杂的读写锁，还可以在aqs的基础上衍生出更多，如countDownLatch,cyclicBarrier等，可以支持我们做更多,但是不是lock就可以完全替代synchronized了呢，其实synchronized也有自己的优点，简单，不易出错，性能也不比lock差(有的书上写道synchronized性能比lock好，但其实就算好也不会好太多，对于我们来说，基本上可以忽略)，真要说选哪个，我的建议是优先选synchronized，如果有特殊业务特殊需求synchronized无法满足，那当然是要用lock，不过，一定要记得释放锁哦。

本来打算结合reentrant和synchronized直接串起来讲的，但是确实有点多，这一篇就当作是后面的引子吧。