---

一、常见的锁策略

1.乐观锁 和 悲观锁（预测锁冲突的概率）

​ 1.乐观锁和悲观锁都是泛指的概念。是“锁的一种特性”，是一类锁，而不是具体的锁。

悲观乐观，是根据对后续锁冲突是否激烈（频发）给出的预测。

• 如果预测接下来锁冲突的概率不大，就可以少做一些工作，就称为“乐观锁”。

乐观锁认为多个线程访问同一个共享变量冲突的概率不大. 并不会真的加锁, 而是直接尝试访问数

据. 在访问的同时识别当前的数据是否出现访问冲突.

• 如果预测接下来锁冲突的概率很大，就应该多做一些工作，就称为”悲观锁“。

悲观锁总是假设最坏的情况，每次去拿数据的时候，都认为别人会修改。所以在每次拿到数据时都会上锁，这样其他线程想拿这个数据的时候，就会发生阻塞。

​ 2.乐观锁的一个重要功能就是检查出数据是否发生了访问冲突。可以引入“版本号”来解决。

​ 3.Synchronized 初始使用乐观锁策略，当发现锁竞争比较频繁的时候, 就会自动切换成悲观锁策略

---

2.轻量级锁 和 重量级锁 （实际消耗的开销）

• 锁的核心特点是“原子性”，由于CPU提供了“原子操作指令”，操作系统基于CPU的原子指令，实现了mutex互斥锁。JVM基于操作系统提供的互斥锁，实现了synchronized和ReentrantLock等关键字和类

​ 轻量级锁是指，锁的开销比较小，消耗的资源少。乐观锁通常是轻量级锁，可能存在特例，不绝对。

加锁机制尽可能不适用mutex,尽量使用用户态。少量的内核态用户态切换，不容易引发线程调度。

​ 重量级锁是指，锁的开销比较大，消耗的资源多。悲观锁通过是重量级锁。

加锁机制严重依赖mutex,存在大量的用户态内核态切换，容易引发线程的调度。

synchronized 开始是一个轻量级锁. 如果锁冲突比较严重, 就会变成重量级锁

---

3.自旋锁 和 挂起等待锁

自旋锁（Spin Lock）

​ 就属于一种轻量级锁的典型实现。往往在纯用户态实现，比如使用了一个While循环，不停的检查当前锁是否被释放。如果没被释放就继续进行循环，释放了就获取到锁，从而结束循环。不涉及到内核和阻塞,属于’‘忙等’'。相当于消耗CPU来换取更快的响应速度。

挂起等待锁

​ 就属于一种重量级锁的典型实现。要借助系统api来实现，一旦出现锁竞争，就会在内核中触发一系列动作（比如让这个线程进入阻塞状态，暂时不参与CPU的调度。阻塞的开销是比较大的）

4.读写锁

读写锁，就是把“读”和“写”两种操作区别开来：

1.读加锁 ：读的时候，能读，但是不能写。

2.写加锁 ：写的时候，不能读，也不能写。

​ 读锁和读锁之间，不会产生竞争（多线程读取同一个数据，没有线程安全问题）。读锁和写锁有竞争。写锁和写锁也有竞争。在实际的开发中，往往是“读多写少”。使用读写锁，就可以优化“读多写少”这样的场景。

标准库中读写锁的实现

• ReentrantReadWriteLock.ReadLock 类表示一个读锁. 这个对象提供了 lock / unlock 方法进行加锁解锁.

• ReentrantReadWriteLock.WriteLock 类表示一个写锁. 这个对象也提供了 lock / unlock 方法进行加锁解锁

要进行区别：在数据库，事务的隔离性中涉及到：

1.解决脏读 ：写加锁（我写的时候，别人不能去读）

2.解决不可重复读 ：读加锁：（你读的时候，我也不能写）

3.解决幻读 ：串行化

数据库写加锁：写的时候不能读

数据库读加锁：读的时候不能写（是简化版本的模型）

• synchronized不是读写锁。

5.可重入锁 和 不可重入锁

一个线程对同一把锁，连续加锁两次，不会死锁，就是可重入锁。会死锁，就是不可重入锁。

可重入锁，锁里面保存了当前是哪个线程加上的锁，同时维护了一个计数器，所以第二次加锁的时候，不会触发阻塞等待，而是自增计数器。后续解锁时再进行自减。直到计数器等于0时，才会真正释放锁。

6.公平锁 和 非公平锁

• 这里的公平，指的是，对排队等待的线程公平，而不是值人人平等~

​ 当很多线程去尝试加一把锁的时候，一个线程拿到锁，其他线程就会阻塞等待。当第一个线程释放锁时：

公平锁：剩下的线程 按照“先来后到"的顺序，来拿到锁。

非公平锁：剩下的线程以“均等”的概率，重新竞争锁。

操作系统提供的加锁API,默认情况下，就属于非公平锁。

要想实现 公平锁 ，需要引入额外的队列，来维护这些线程的加锁顺序。

点击移步博客主页，欢迎光临~