锁系列一：有哪些锁机制？_锁机制有哪些

一.锁

分类

（按照锁的特性和涉及来划分）

1.公平锁/非公平锁

• 公平锁是指多个线程按照申请锁的顺序来获取锁。

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

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

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

2.可重入锁

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

对于Java ReetrantLock而言，从名字就可以看出是一个重入锁，其名字是Reentrant Lock 重新进入锁。

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

1 synchronized void setA() throws Exception{
2 　　Thread.sleep(1000);
3 　　setB();
4 }
5 
6 synchronized void setB() throws Exception{
7 　　Thread.sleep(1000);
8 }
1
2
3
4
5
6
7
8

上面的代码就是一个可重入锁的一个特点。如果不是可重入锁的话，setB可能不会被当前线程执行，可能造成死锁

3.独享锁/共享锁

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

共享锁是指该锁可被多个线程所持有。

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

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

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

对于Synchronized而言，当然是独享锁。

4.互斥锁/读写锁

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

互斥锁在Java中的具体实现就是ReentrantLock。

读写锁在Java中的具体实现就是ReadWriteLock。

5.乐观锁/悲观锁

5.1乐观锁：

顾名思义就很乐观，就是每一次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号等机制。

• 适用特点

  • 多用于读较多的场景，可以提高吞吐量
  • 在java中的使用就是无锁编程，常用的算法是CAS算法，典型的例子就是原子类，通过CAS自旋实现原子操作的更新

• 数据版本机制

  • 使用版本号实现

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

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

  • 使用时间戳实现

• CAS操作(compare and swap 比较并交换)

  当多个线程尝试使用CAS同时更新一个变量时，只有其中一个线程能跟新变量的值，而其他的线程都失败，失败的线程并不会被挂起，而是被告知这次竞争失败，并可以再次尝试。

  CAS包含三个操作数——需要读写的内存位置（V），进行比较的预期原值（A）和拟写入的新值（B）。如果内存位置V的值与预期的A相匹配，那么处理器就自动将该位置的值更新为B，否则处理器不会做任何操作

5.2悲观锁：

总是假设是最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次拿数据的时候都会上锁，这样别人想要拿到数据就会被阻塞直到它拿到数据。

• 试用特点：
  • 适用于写多的场景
  • java里面的同步语句synchronized关键字的实现就是悲观锁

6.分段锁

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

我们以ConcurrentHashMap来说一下分段锁的含义以及设计思想，ConcurrentHashMap中的分段锁称为Segment，它即类似于HashMap（JDK7和JDK8中HashMap的实现）的结构，即内部拥有一个Entry数组，数组中的每个元素又是一个链表；同时又是一个ReentrantLock（Segment继承了ReentrantLock）。

当需要put元素的时候，并不是对整个hashmap进行加锁，而是先通过hashcode来知道他要放在哪一个分段中，然后对这个分段进行加锁，所以当多线程put的时候，只要不是放在一个分段中，就实现了真正的并行的插入。

但是，在统计size的时候，就是获取hashmap全局信息的时候，就需要获取所有的分段锁才能统计。

分段锁的设计**目的是细化锁的粒度，**当操作不需要更新整个数组的时候，就仅仅针对数组中的一项进行加锁操作。

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

这三种锁是指锁的状态，并且是针对Synchronized。在Java 5通过引入锁升级的机制来实现高效Synchronized。这三种锁的状态是通过对象监视器在对象头中的字段来表明的。

• 偏向锁是指一段同步代码一直被一个线程所访问，那么该线程会自动获取锁。降低获取锁的代价。

• 轻量级锁是指当锁是偏向锁的时候，被另一个线程所访问，偏向锁就会升级为轻量级锁，其他线程会通过自旋的形式尝试获取锁，不会阻塞，提高性能。

• 重量级锁是指当锁为轻量级锁的时候，另一个线程虽然是自旋，但自旋不会一直持续下去，当自旋一定次数的时候，还没有获取到锁，就会进入阻塞，该锁膨胀为重量级锁。重量级锁会让他申请的线程进入阻塞，性能降低。

8.自旋锁（java.util.concurrent包下的几乎都是利用锁）

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

AQS

AbstractQueuedSynchronized 抽象队列式的同步器，AQS定义了一套多线程访问共享资源的同步器框架，许多同步类实现都依赖于它，如常用的ReentrantLock/Semaphore/CountDownLatch…

AQS维护了一个volatile int state(代表共享资源)和一个FIFO线程等待队列（多线程争用资源被阻塞时会进入此队列）。

state的访问方式有三种：

getState()
setState()
compareAndSetState()
1
2
3

AQS定义两种资源共享方式：Exclusive（独占，只有一个线程能执行，如ReentrantLock）和Share（共享，多个线程可同时执行，如Semaphore/CountDownLatch）。

1 AQS核心思想

如果被请求的共享资源空闲，则将当前请求资源的线程归为有效工作线程，并且该资源设置为锁定状态。其他线程如果要请求该共享资源，由于该资源被占有，因此无法请求成功，那么就需要一套线程阻塞等待以及唤醒时锁分配的机制。这个机制AQS使用CLH队列锁实现的，即将暂时获取不到锁的线程加入到队列中。

在AbstractQueuedSynchronizer类中有介绍CLH(Craig, Landin, and Hagersten)，CLH队列是一个虚拟的双向队列(虚拟的双向对立是不存在队列实例，而是通过Node节点之间的关系关联)

2 利用AQS获取锁流程时序图

3 state变量的作用

AQS使用int类型的state标示锁的状态。使用CAS对同步状态进行原子性操作实现状态修改。

private volatile int state;  // The synchronization state. volatile保证线程可见
1

获取同步状态的源代码：

// 获取同步的状态
protected final int getState() {
        return state;
    }
// 设置同步的状态
protected final void setState(int newState) {
    state = newState;
}
// 通过CAS设置同步的状态
protected final boolean compareAndSetState(int expect, int update) {
    return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}
1
2
3
4
5
6
7
8
9
10
11
12

4 AQS中Node节点常量含义

volatile int waitStatus;

int CANCELLED =  1;//waitStatus值为1时表示该线程节点已释放（超时、中断），已取消的节点不会再阻塞。
int SIGNAL    = -1;//waitStatus为-1时表示该线程的后续线程需要阻塞，即只要前置节点释放锁，就会通知标识为 SIGNAL 状态的后续节点的线程 
int CONDITION = -2; //waitStatus为-2时，表示该线程在condition队列中阻塞（Condition有使用）
int PROPAGATE = -3;//waitStatus为-3时，表示该线程以及后续线程进行无条件传播（CountDownLatch中有使用）共享模式下， PROPAGATE 状态的线程处于可运行状态 
waiteStatus 为 0:          None of the above // 初始状态
1
2
3
4
5
6
7

5 AQS定义两种资源共享方式

Exclusive（独占）：只有一个线程能执行，如ReentrantLock。又可分为公平锁和非公平锁：

• 公平锁：按照线程在队列中的排队顺序，先到者先拿到锁
• 非公平锁：当线程要获取锁时，无视队列顺序直接去抢锁，谁抢到就是谁的

Share（共享）：多个线程可同时执行，如Semaphore/CountDownLatch。Semaphore、CountDownLatch、 CyclicBarrier、ReadWriteLock的Read锁。

不同的自定义同步器争用共享资源的方式也不同。自定义同步器在实现时只需要实现共享资源 state 的获取与释放方式即可，至于具体线程等待队列的维护（如获取资源失败入队/唤醒出队等），AQS已经在底层实现好了。

6 AQS底层用模板方法模式

AQS底层是模板方法模式的，如果需要自定义同步器，一般方法是：继承AQS，并重写指定方法(无非是按照自己定义的规则对state的获取与释放)；将AQS组合在自定义同步组件的实现中，并调用模板方法，而这些模板方法会调用重写的方法。

需要重写的方法：

isHeldExclusively()//该线程是否正在独占资源。只有用到condition才需要去实现它。
tryAcquire(int)//独占方式。尝试获取资源，成功则返回true，失败则返回false。
tryRelease(int)//独占方式。尝试释放资源，成功则返回true，失败则返回false。
tryAcquireShared(int)//共享方式。尝试获取资源。负数表示失败；0表示成功，但没有剩余可用资源；正数表示成功，且有剩余资源。
tryReleaseShared(int)//共享方式。尝试释放资源，成功则返回true，失败则返回false。
1
2
3
4
5

以上方法默认抛出UnsupportedOperationException异常，AQS类中的其他方法都是final ，所以无法被其他类使用，只有这几个方法可以被其他类使用。

以ReentrantLock为例，state初始化为0，表示未锁定状态。A线程lock()时，会调用tryAcquire()独占该锁并将state+1。此后，其他线程再tryAcquire()时就会失败，直到A线程unlock()到state=0（即释放锁）为止，其它线程才有机会获取该锁。当然，释放锁之前，A线程自己是可以重复获取此锁的（state会累加），这就是可重入的概念。但要注意，获取多少次就要释放多么次，这样才能保证state是能回到零态的

7 ReentrantLock使用AQS的交互图

CAS

在JDK1.5中新增java.util.concurrent包就是建立在CAS之上的。相对于synchronized这种阻塞算法，CAS是非阻塞算法的一种常见实现。

ReentrantLock

ReentrantLock既可以构造公平锁又可以构造非公平锁，默认为非公平锁.

ReentrantReadWriteLock

二.线程安全之可见性

1.多线程的问题

• 所见非所得
• 无法肉眼去检测程序的准确性
• 不同运行平台有不同的表现
• 错误很难重现

工作内存缓存

CPU指令重排序：java编程语言的语义允许java编译器和微处理器进行执行优化，这些导致了与之交互的代码不在同步，从而导致看似矛盾的行为

java介于脚本语言 和 编译语言 之间

2. volatile关键字

volatile的功能

​ 取消jvm对代码的编译优化，不会进行指令重排

​ 禁止缓存，volatile变量的访问控制符会加个ACC_VOLATILE

volatile修饰的变量对所有线程的可见性。这里的可见性是什么意思呢？当一个线程修改了变量的值，新的值会立刻同步到主内存当中。而其他线程读取这个变量的时候，也会从主内存中拉取最新的变量值。

3.Shared Variables定义

可以在线程之间共享的内存成为 共享内存或堆操作

所有的 实例字段，静态字段 和 数组元素都存储在堆内存中，这些字段和数组都是标题中提到的共享变量。

冲突： 如果 至少有一个访问是写操作，那么对同一个变量的两次访问是冲突的。

这些能被多个线程访问的共享变量是内存模型规范的对象。

4.notify（） 和notifyAll（）

notify可能导致死锁，而notifyAll不会。notifyAll可以换新多个线程，而notify只能唤醒一个线程

5.sleep（）和wait（）

sleep属于Thread类；调用时线程不会释放对象锁

wait属于Object类，调用时线程会放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象的notify方法后本县城才进入对象锁定池准备获取对象锁进入运行状态

6.start（）和run（）

start用于启动新创建的线程，它的内部调用了run方法。

但是如果直接调用run方法，只会在原来的线程中调用，没有新的线程启动