Java基础知识之锁机制

1、锁的分类

1. 公平锁/非公平锁
2. 可重入锁
3. 独享锁/共享锁
4. 互斥锁/读写锁
5. 乐观锁/悲观锁
6. 分段锁
7. 偏向锁/轻量级锁/重量级锁
8. 自旋锁

1.1、公平锁/非公平锁：

1. 公平锁是指多个线程按照申请锁的顺序来获取锁。
2. 非公平锁是指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程比先申请的线程优先获取锁。有可能，会造成优先级反转或者饥饿现象。
   比如线程中给线程设置优先级

1.2、可重入锁 / 递归锁：

可重入锁又名递归锁，是指在同一个线程在外层方法获取锁的时候，在进入内层方法会自动获取锁。

// 此处用代码演示了可重入锁的代码层意思
synchronized void setA() throws Exception{   
    Thread.sleep(1000);
    setB();   // 因为获取了setA()的锁（即获取了方法外层的锁）、此时调用setB()将会自动获取setB()的锁，如果不自动获取的话方法B将不会执行           
}
 
synchronized void setB() throws Exception{
    Thread.sleep(1000);
}

1.3、独享锁/共享锁：

独享锁是指该锁一次只能被一个线程所持有。
共享锁是指该锁可被多个线程所持有。

1.4、互斥锁/读写锁

上面讲的独享锁/共享锁就是一种广义的说法，互斥锁/读写锁就是具体的实现。

1.5、乐观锁/悲观锁

乐观锁与悲观锁不是指具体的什么类型的锁，而是指看待并发同步的角度。

1. 悲观锁认为对于同一个数据的并发操作，一定是会发生修改的，哪怕没有修改，也会认为修改。因此对于同一个数据的并发操作，悲观锁采取加锁的形式。悲观的认为，不加锁的并发操作一定会出问题。
2. 乐观锁则认为对于同一个数据的并发操作，是不会发生修改的。在更新数据的时候，会采用尝试更新，不断重新的方式更新数据。乐观的认为，不加锁的并发操作是没有事情的。

从上面的描述我们可以看出，悲观锁适合写操作非常多的场景，乐观锁适合读操作非常多的场景，不加锁会带来大量的性能提升。
悲观锁在Java中的使用，就是利用各种锁。
乐观锁在Java中的使用，是无锁编程，常常采用的是CAS算法，典型的例子就是原子类，通过CAS自旋实现原子操作的更新。

重量级锁是悲观锁的一种，自旋锁、轻量级锁与偏向锁属于乐观锁

1.6、分段锁

分段锁其实是一种锁的设计，并不是具体的一种锁，对于ConcurrentHashMap(JDK7)而言，其并发的实现就是通过分段锁的形式来实现高效的并发操作。

1.7、偏向锁/轻量级锁/重量级锁

这三种锁是指锁的状态，并且是针对Synchronized。
偏向锁是指一段同步代码一直被一个线程所访问，那么该线程会自动获取锁。降低获取锁的代价。
轻量级锁是指当锁是偏向锁的时候，被另一个线程所访问，偏向锁就会升级为轻量级锁，其他线程会通过自旋的形式尝试获取锁，不会阻塞，提高性能。
重量级锁是指当锁为轻量级锁的时候，另一个线程虽然是自旋，但自旋不会一直持续下去，当自旋一定次数的时候，还没有获取到锁，就会进入阻塞，该锁膨胀为重量级锁。重量级锁会让其他申请的线程进入阻塞，性能降低。

1.8、自旋锁

在Java中，自旋锁是指尝试获取锁的线程不会立即阻塞，而是采用循环的方式去尝试获取锁，这样的好处是减少线程上下文切换的消耗，缺点是循环会消耗CPU。

2、锁作用及实现

锁机制的种类：Sychornized 锁 和 Lock锁
Synchronized是基于JVM来保证数据同步的，而Lock则是在硬件层面，依赖特殊的CPU指令实现数据同步的

1. Synchronized：非公平，悲观，独享，互斥，可重入的重量级锁
2. ReentrantLock：默认非公平但可实现公平的，悲观，独享，互斥，可重入，重量级锁。
3. ReentrantReadWriteLocK：默认非公平但可实现公平的，悲观，写独享，读共享，读写，可重入，重量级锁。

2.1、Synchronized的作用：

Synchronized可以把任意一个非NULL的对象当作锁。

1. 作用于方法时，锁住的是对象的实例(this)；
2. 当作用于静态方法时，锁住的是Class实例，又因为Class是全局共享的，因此静态方法锁相当于类的一个全局锁，会锁所有调用该方法的线程；
3. 作用于一个对象实例时，锁住的是所有以该对象为锁的代码块。
4. 作用于一段代码块时，锁住的是这段代码块被运行且未运行结束时，其他线程不允许执行该段代码块

2.2、Lock锁简介：

Lock锁是纯Java实现的，与底层的JVM无关。在java.util.concurrent.locks包中有很多Lock的实现类，常用的ReentrantLock、ReadWriteLock（实现类ReentrantReadWriteLock），其实现都依赖java.util.concurrent.AbstractQueuedSynchronizer类（简称AQS）

3、什么是死锁？如何避免死锁？

1. 定义：指由于两个或者多个线程互相持有对方所需要的资源，导致这些线程处于等待状态，无法前往执行。

2. 产生的条件：

   1. 互斥条件：进程对于所分配到的资源具有排它性，即一个资源只能被一个进程占用，直到被该进程释放
   2. 请求和保持条件：一个进程因请求被占用资源而发生阻塞时，对已获得的资源保持不放。
   3. 不剥夺条件：任何一个资源在没被该进程释放之前，任何其他进程都无法对他剥夺占用
   4. 循环等待条件：当发生死锁时，所等待的进程必定会形成一个环路（类似于死循环），造成永久阻塞。

3. 避免死锁：
   在有些情况下死锁是可以避免的。本文将展示三种用于避免死锁的技术：

   1. 加锁顺序
      确保所有的线程都是按照相同的顺序获得锁，那么死锁就不会发生
   2. 加锁时限
      尝试获取锁的过程中若超过了这个时限该线程则放弃对该锁请求
   3. 死锁检测
      当一个线程请求锁失败时，这个线程可以遍历锁的关系图看看是否有死锁发生