浅谈Java锁机制---公平锁/非公平锁,可重入锁(递归锁),独享锁/共享锁,互斥锁/读写锁,乐观锁/悲观锁,分段锁,偏向锁/轻量级锁/重量级锁,可中断锁,自旋锁

古城微笑少年丶 2023-01-18 02:20 191阅读 0赞

参考文章：[浅谈Java锁机制][Java]

[JAVA锁机制-可重入锁,可中断锁，公平锁，读写锁，自旋锁][JAVA_-]

**Java常见锁类型：**

>  *  公平锁/非公平锁
>  *  可重入锁(递归锁)
>  *  独享锁/共享锁
>  *  互斥锁/读写锁
>  *  乐观锁/悲观锁
>  *  分段锁
>  *  偏向锁/轻量级锁/重量级锁
>  *  可中断锁
>  *  自旋锁

![b9e505311ba12697cb1c3513e11df8a7.png][]

## 锁的相关概念介绍 ##

### **1. 公平锁/非公平锁：** ###

>  *  **公平锁**是指多个线程按照申请锁的顺序来获取锁, 比如同是有多个线程在等待一个锁，当这个锁被释放时，等待时间最久的线程（最先请求的线程）会获得该所，这种就是公平锁。
>  *  **非公平锁**是指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程比先申请的线程优先获取锁，有可能会造成优先级反转或者饥饿现象。
> 
> 在Java中，synchronized是非公平锁，它无法保证等待的线程获取锁的顺序。  
> 而对于ReentrantLock和ReentrantReadWriteLock，它默认情况下是非公平锁，但是可以设置为公平锁。

### 2. 可重入锁(递归锁)： ###

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

**例如：**

当一个线程执行到某个synchronized方法时，例如synchronized方法method1，在method1中调用另外一个synchronized方法method2，此时线程不必重新去申请锁，而是可以直接执行方法method2 ：

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

### 3. 独享锁/共享锁： ###

>  *  **独享锁**是指该锁一次只能被一个线程所持有
>  *  **共享锁**是指该锁可被多个线程所持有
> 
> Java ReentrantLock是独享锁。  
> Synchronized是独享锁。  
> Lock的另一个实现类ReadWriteLock读锁是共享锁，其写锁是独享锁。  
> 读锁的共享锁可保证并发读是非常高效的，读写，写读 ，写写的过程是互斥的。  
> 独享锁与共享锁也是通过AQS来实现的，通过实现不同的方法，来实现独享或者共享。

### 4. 互斥锁/读写锁 ###

> 独享锁/共享锁就是一种广义的说法，互斥锁/读写锁就是具体的实现。  
> 读写锁**将对一个资源（比如文件）的访问分成了2个锁，一个读锁和一个写锁**。  
> 正因为有了读写锁，才使得多个线程之间的读操作不会发生冲突。  
> ReadWriteLock就是读写锁，它是一个接口，ReentrantReadWriteLock实现了这个接口。  
> 可以通过readLock()获取读锁，通过writeLock()获取写锁。

### 5. 乐观锁/悲观锁 ###

> 乐观锁与悲观锁不是指具体的什么类型的锁，而是指看待并发同步的角度。  
> 悲观锁认为对于同一个数据的并发操作，一定是会发生修改的，哪怕没有修改，也会认为修改。因此对于同一个数据的并发操作，悲观锁采取加锁的形式。悲观的认为，不加锁的并发操作一定会出问题。  
> 乐观锁则认为对于同一个数据的并发操作，是不会发生修改的。在更新数据的时候，会采用尝试更新，不断重新的方式更新数据。乐观的认为，不加锁的并发操作是没有事情的。
> 
> 从上面的描述我们可以看出，悲观锁适合写操作非常多的场景，乐观锁适合读操作非常多的场景，不加锁会带来大量的性能提升。  
> 悲观锁在Java中的使用，就是利用各种锁。  
> 乐观锁在Java中的使用，是无锁编程，常常采用的是CAS算法，典型的例子就是原子类，通过CAS自旋实现原子操作的更新。
> 
>  *  重量级锁是悲观锁的一种
>  *  自旋锁、轻量级锁与偏向锁属于乐观锁

### 6. 分段锁 ###

> 分段锁其实是一种锁的设计，并不是具体的一种锁，对于**`ConcurrentHashMap`**而言，其并发的实现就是通过分段锁的形式来实现高效的并发操作。  
> 我们以**`ConcurrentHashMap`**来说一下分段锁的含义以及设计思想，**`ConcurrentHashMap`**中的分段锁称为Segment，它即类似于HashMap（JDK7与JDK8中HashMap的实现）的结构，即内部拥有一个Entry数组，数组中的每个元素又是一个链表；同时又是一个ReentrantLock（Segment继承了ReentrantLock)。  
> 当需要put元素的时候，并不是对整个hashmap进行加锁，而是先通过hashcode来知道他要放在那一个分段中，然后对这个分段进行加锁，所以当多线程put的时候，只要不是放在一个分段中，就实现了真正的并行的插入。  
> 但是，在统计size的时候，可就是获取hashmap全局信息的时候，就需要获取所有的分段锁才能统计。  
> 分段锁的设计目的是细化锁的粒度，当操作不需要更新整个数组的时候，就仅仅针对数组中的一项进行加锁操作。

## 7. 偏向锁/轻量级锁/重量级锁 ##

> 这三种锁是指锁的状态，并且是针对**`Synchronized`**。在Java 5通过引入锁升级的机制来实现高效**`Synchronized`**。这三种锁的状态是通过对象监视器在对象头中的字段来表明的。
> 
>  *  偏向锁是指**一段同步代码一直被一个线程所访问，那么该线程会自动获取锁，降低获取锁的代价**。
> 
> 偏向锁的适用场景
> 
> 始终只有一个线程在执行同步块，在它没有执行完释放锁之前，没有其它线程去执行同步块，在锁无竞争的情况下使用，一旦有了竞争就升级为轻量级锁，升级为轻量级锁的时候需要撤销偏向锁，撤销偏向锁的时候会导致stop the word操作；   
> 在有锁的竞争时，偏向锁会多做很多额外操作，尤其是撤销偏向所的时候会导致进入安全点，安全点会导致stw，导致性能下降，这种情况下应当禁用；
> 
>  *  轻量级锁是指**当锁是偏向锁的时候，被另一个线程所访问，偏向锁就会升级为轻量级锁，其他线程会通过自旋的形式尝试获取锁，不会阻塞，提高性能**。
>  *  重量级锁是指**当锁为轻量级锁的时候，另一个线程虽然是自旋，但自旋不会一直持续下去，当自旋一定次数的时候，还没有获取到锁，就会进入阻塞，该锁膨胀为重量级锁。重量级锁会让其他申请的线程进入阻塞，性能降低**。

### 8. 自旋锁 ###

> 在Java中，自旋锁是**指尝试获取锁的线程不会立即阻塞，而是采用循环的方式去尝试获取锁，这样的好处是减少线程上下文切换的消耗，缺点是循环会消耗CPU**。
> 
> 自旋锁原理非常简单，如果持有锁的线程能在很短时间内释放锁资源，那么那些等待竞争锁的线程就不需要做内核态和用户态之间的切换进入阻塞挂起状态，它们只需要等一等（自旋），等持有锁的线程释放锁后即可立即获取锁，这样就**避免用户线程和内核的切换的消耗**。
> 
> 自旋锁尽可能的减少线程的阻塞，适用于锁的竞争不激烈，且占用锁时间非常短的代码块来说性能能大幅度的提升，因为自旋的消耗会小于线程阻塞挂起再唤醒的操作的消耗
> 
> 但是如果锁的竞争激烈，或者持有锁的线程需要长时间占用锁执行同步块，这时候就不适合使用自旋锁了，因为自旋锁在获取锁前一直都是占用cpu做无用功，同时有大量线程在竞争一个锁，会导致获取锁的时间很长，线程自旋的消耗大于线程阻塞挂起操作的消耗，其它需要cpu的线程又不能获取到cpu，造成cpu的浪费。
> 
> **自旋锁可能引起的问题：**
> 
> 1.  过多占据CPU时间：如果锁的当前持有者长时间不释放该锁，那么等待者将长时间的占据cpu时间片，导致CPU资源的浪费，因此可以设定一个时间，当锁持有者超过这个时间不释放锁时，等待者会放弃CPU时间片阻塞；
> 2.  死锁问题：试想一下，有一个线程连续两次试图获得自旋锁（比如在递归程序中），第一次这个线程获得了该锁，当第二次试图加锁的时候，检测到锁已被占用（其实是被自己占用），那么这时，线程会一直等待自己释放该锁，而不能继续执行，这样就引起了死锁。因此递归程序使用自旋锁应该遵循以下原则：递归程序决不能在持有自旋锁时调用它自己，也决不能在递归调用时试图获得相同的自旋锁。

**JAVA中一种自旋锁的实现：**   CAS是Compare And Set的缩写

import java.util.concurrent.atomic.AtomicReference;  
    class SpinLock {  
        //java中原子（CAS）操作  
        //持有自旋锁的线程对象
        AtomicReference<Thread> owner = new AtomicReference<Thread>();  
        private int count;  
    
        public void lock() {  
            Thread cur = Thread.currentThread();  
            
            // lock函数将owner设置为当前线程，并且预测原来的值为空。
            // unlock函数将owner设置为null，并且预测值为当前线程。
            // 当有第二个线程调用lock操作时由于owner值不为空，导致循环    
      
            // 一直被执行，直至第一个线程调用unlock函数将owner设置为null，
            // 第二个线程才能进入临界区。  
            while (!owner.compareAndSet(null, cur)){  
            }  
        }  
    
        public void unLock() {  
            Thread cur = Thread.currentThread();  
                owner.compareAndSet(cur, null);  
            }  
        }  
    } 
     
    public class Test implements Runnable {  
        static int sum;  
        private SpinLock lock;  
          
        public Test(SpinLock lock) {  
            this.lock = lock;  
        }  
        public static void main(String[] args) throws InterruptedException {  
            SpinLock lock = new SpinLock();  
            for (int i = 0; i < 100; i++) {  
                Test test = new Test(lock);  
                Thread t = new Thread(test);  
                t.start();  
            }  
              
            Thread.currentThread().sleep(1000);  
            System.out.println(sum);  
        }  
          
        @Override  
        public void run() {  
            this.lock.lock();  
            sum++;  
            this.lock.unLock();  
        }  
    }

### **9. 可中断锁** ###

> 可中断锁：顾名思义，就是可以相应中断的锁。
> 
> 在Java中，synchronized就不是可中断锁，而Lock是可中断锁。
> 
> 如果某一线程A正在执行锁中的代码，另一线程B正在等待获取该锁，可能由于等待时间过长，线程B不想等待了，想先处理其他事情，我们可以让它中断自己或者在别的线程中中断它，这种就是可中断锁。
> 
> 在前面演示lockInterruptibly()的用法时已经体现了Lock的可中断性。

### 10. Synchronized, ReentrantLock, ReentrantReadWriteLocK总结 ###

Synchronized是基于JVM来保证数据同步的，而Lock则是在硬件层面，依赖特殊的CPU指令实现数据同步的

>  *  Synchronized，它就是一个：非公平，悲观，独享，互斥，可重入，不可中断的重量级锁
>  *  ReentrantLock，它是一个：默认非公平但可实现公平的，悲观，独享，互斥，可重入，重量级锁
>  *  ReentrantReadWriteLocK，它是一个，默认非公平但可实现公平的，悲观，写独享，读共享，读写，可重入，重量级锁

[Java]: https://blog.csdn.net/qq_41181619/article/details/81407289
[JAVA_-]: https://www.cnblogs.com/aspirant/p/6930436.html
[b9e505311ba12697cb1c3513e11df8a7.png]: /images/20221021/845f467b869a42a88ef10b7331912b88.png