从synchronized和lock区别入手聊聊java锁机制
写这篇文章之前，我去百度了一下啥叫锁，百度百科上写道：置于可启闭的器物上，以钥匙或暗码开启。确实我们一般理解的锁就是门锁，密码锁，但是在计算机科学中，锁又是啥，说实话，这个问题我也思考了很久，也没法很好的用一两句话就让人听得明白，也不想有人看到我的文章，然后将我的结论当作答案，我觉得最好的答案还是在探索的过程中得到的，接下来我们就好好探索一番。
作为一名java程序员，最开始接触到的锁就是synchronized，书本上是这么写的，老师也是这么说的，至于为啥叫锁，可能也没多少人真的去思考过。不知道有没有同学和我一样，经历过只知道用synchronized，后来逐渐的了解ReentrantLock,读写锁，然后又了解了aqs,后来通过百度google,看一些博客(这个我要吐槽一下，在学习过程中遇到过很多文章写的有问题的，反而误导了我)，后面看了看synchronized的源码，最后对比synchronized和ReentrantLock才加深了对锁的一些认知（说实话，作为一个刚毕业3年的非科班出身码农，我也不敢保证自己写的就一定对，算是学习过程中的一些感悟吧），那接下来我就按照学习顺序来逐渐展开。
先来一段简单的synchronized使用代码：
public static void main(String[] args) { String s = new String();
synchronized (s) {
TestJni jni = new TestJni();
jni.jniHello();
}
}
上面代码做的事情很简单，如下图所示，有A B C D E多个线程同时来到synchronized包含的代码块，A先一步进来了，那么BCDE都得等，等我A执行完他们才能进来执行。
synchronized用起来确实很简单,我们也可以放在方法上，但是其本质还是锁的对象，这个我们后面分析源码一看就知道了。
随着开发时间越长，synchronized在有些复杂场景下(如需要可中断，可控制时间抢锁，需要多个等待队列分别控制，读写锁等场景的时候)无法满足我们的需求，那么就要用到Lock,下面我们先介绍一下Lock的简单使用：
Lock lock = new ReentrantLock();lock.lock();
try {
System.out.println("线程："+Thread.currentThread().getName()+ " 进来啦");
}finally {
lock.unlock();
}
上面是一种最简单的使用，和synchronized作用是一样的,不过加锁之后必须要解锁，且必须紧跟try - finally块解锁，使用起来稍微复杂一点，容易出错。
我们再介绍一种可中断的使用方式：
public static void main(String[] args) { Thread thread = new Thread(() -> {
try {
lock.lockInterruptibly();
try {
testLock();
} finally {
lock.unlock();
}
} catch (Exception e){
}
});
thread.start();
thread.interrupt();
}
public static void testLock(){
condition.signalAll();
System.out.println("线程："+Thread.currentThread().getName()+ " 进来啦");
}
这种方式呢，在拿锁被park住了，如果刚好这时候被打断了，就会响应打断退出抢锁并抛出异常，至于捕获到异常开发者怎么做，那就得根据业务来分别处理了。
而像可控制时间的其实就要稍微复杂一点，先看一下synchronized中的使用：
static TestHash s = new TestHash();public static void main(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 void testLock(){
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 = new ReentrantLock();static Condition condition = lock.newCondition();
public static void main(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 void testWaitSingal(){
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直接串起来讲的，但是确实有点多，这一篇就当作是后面的引子吧。
以上是 从synchronized和lock区别入手聊聊java锁机制 的全部内容， 来源链接： utcz.com/z/393575.html
