给大伙来梳理下Java中的各种锁的分类

墨蓝 2023-02-17 05:18 40阅读 0赞

大伙在面试的时候应该会经常碰到`线程` `并发`方面的问题，而且也会问到你各种分布式锁的概念，本文就给大家整理了下各种锁的分类，希望对你有所帮助。

# 锁的分类 #

我们先总体的来看看有哪些具体的分类

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NTI2NTcz_size_16_color_FFFFFF_t_70]

## 一、乐观锁/悲观锁 ##

注意，`乐观锁`与`悲观锁`并不是具体的两种锁的实现，而一种设计思想。

### 乐观锁 ###

顾名思义，就是很乐观，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用`版本号`等机制。  
  乐观锁适用于`多读`的应用类型，这样可以提高吞吐量，不加锁会带来大量的性能提升,在Java中`java.util.concurrent.atomic`包下面的原子变量类就是使用了乐观锁的一种实现方式CAS(Compare and Swap 比较并交换)实现的。

#### 实现方式 ####

##### 数据版本机制 #####

实现数据版本一般有两方式，

1.  第一种是使用版本号
2.  第二种是使用时间戳。

以版本号方式为例。

版本号方式：一般是在数据表中加上一个数据版本号version字段，表示数据被修改的次数，当数据被修改时，version值会加一。当线程A要更新数据值时，在读取数据的同时也会读取version值，在提交更新时，若刚才读取到的version值为当前数据库中的version值相等时才更新，否则重试更新操作，直到更新成功。

update table set xxx=#{xxx}, version=version+1 where id=#{id} and version=#{version};

##### CAS操作 #####

`CAS`（Compare and Swap 比较并交换），当多个线程尝试使用CAS同时更新同一个变量时，只有其中一个线程能更新变量的值，而其它线程都失败，失败的线程并不会被挂起，而是被告知这次竞争中失败，并可以再次尝试。  
  CAS操作中包含三个操作数——需要读写的内存位置(V)、进行比较的预期原值(A)和拟写入的新值(B)。如果内存位置V的值与预期原值A相匹配，那么处理器会自动将该位置值更新为新值B，否则处理器不做任何操作。

### 悲观锁 ###

总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻塞直到它拿到锁。比如Java里面的同步原语synchronized关键字的实现就是悲观锁。  
  悲观锁适合`写`操作非常多的场景,保证数据的安全。

## 二、独享锁/共享锁 ##

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

### ReentrantLock ###

ReentrantLock是独享锁。但是对于Lock的另一个实现类ReadWriteLock，其读锁是共享锁，其写锁是独享锁。

### ReadWriteLock ###

ReadWriteLock，其`读锁`是共享锁，其`写锁是`独享锁。读锁的共享锁可保证并发读是非常高效的，读写，写读，写写的过程是互斥的。

### Synchronized ###

Synchronized是独享锁  
  独享锁与共享锁也是通过`AQS`来实现的，通过实现不同的方法，来实现独享或者共享。

## 三、互斥锁/读写锁 ##

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

## 四、可重入锁 ##

可重入锁又名`递归锁`，是指在同一个线程在外层方法获取锁的时候，在进入内层方法会自动获取锁。说的有点抽象，下面会有一个代码的示例。

### ReetrantLock ###

ReetrantLock从名字就可以看出是一个重入锁，其名字是Re entrant Lock 重新进入锁。

### Synchronized ###

对于Synchronized而言，也是一个可重入锁。可重入锁的一个好处是可一定程度避免死锁。

public class AtomicDemo { 
        // 共享操作的资源 volatile 原子性问题 synchroized Lock AutomicInteger
        private static int count = 0 ;
    
        private static Lock lock = new ReentrantLock();
    
        // 定义操作的方法 重入锁
        private static void incr(){ 
            try { 
                lock.lock();// 枷锁
                Thread.sleep(1);
                count++;
                decr();
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }finally { 
                lock.unlock();
            }
        }
    
        private static void decr(){ 
            try { 
                lock.lock();// 枷锁
                Thread.sleep(1);
                count--;
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }finally { 
                lock.unlock();
            }
        }
    
        public static void main(String[] args) throws InterruptedException { 
            for (int i = 0; i <100 ; i++) { 
                new Thread(new Runnable() { 
                    public void run() { 
                        AtomicDemo.incr();
                    }
                }).start();
            }
    
            Thread.sleep(5000);
            System.out.println("Result:" + count);
        }
    }

## 五、公平锁/非公平锁 ##

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

### ReetrantLock ###

ReetrantLock可以通过构造函数指定该锁是否是公平锁，默认是非公平锁。非公平锁的优点在于吞吐量比公平锁大。

### Synchronized ###

对于Synchronized而言，也是一种非公平锁。由于其并不像ReentrantLock是通过AQS的来实现线程调度，所以并没有任何办法使其变成公平锁。

## 六、分段锁 ##

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

## 七、偏向锁/轻量级锁/重量级锁 ##

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

## 八、自旋锁 ##

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

好了~锁的分类就给大伙介绍到这里，有问题的欢迎大家留言交流！！！

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NTI2NTcz_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200612165908134.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NTI2NTcz,size_16,color_FFFFFF,t_70