锁（三）锁的分类_锁的种类

   锁的分类：

• 乐观锁/悲观锁
• 独享锁/共享锁
• 互斥锁/读写锁
• 可重入锁
• 公平锁/非公平锁
• 分段锁
• 偏向锁/轻量级锁/重量级锁
• 自旋锁

 以上是一些锁的名词，这些分类并不是全是指锁的状态，有的指锁的特性，有的指锁的设计 

一、乐观锁/悲观锁：

并不是特指某两种类型的锁，是人们定义出来的概念或思想，主要是指看待并发同步的角度。

1、乐观锁（Optimistic Lock）

1.1、介绍：

乐观锁总是认为不存在并发问题，每次去取数据的时候，总认为不会有其他线程对数据进行修改，因此不会上锁。只是在数据修改后提交时才通过【版本号机制或者CAS算法】来验证数据是否被其他线程更新。乐观锁适用于多读的应用类型，这样可以提高吞吐量，因为不加锁会带来大量的性能提升。

优点：没有加锁和解锁操作，可以提高吞吐量；

缺点：乐观锁需要自己实现，且外部系统不受控制。

1.2、适用场景：

  乐观锁适用于读多写少的应用类型，这样可以提高吞吐量

1.3、乐观锁策略：

   提交版本必须大于记录当前版本才能执行更新

1.4、实现方法：

  一般会使用版本号机制或CAS操作实现。在Java中java.util.concurrent.atomic包下面的原子变量类就是使用了乐观锁的一种实现方式CAS(Compare and Swap 比较并交换)实现的。

   （1） 数据版本机制

实现数据版本一般有两种，第一种是使用版本号，第二种是使用时间戳。以版本号方式为例。

版本号方式：一般是在数据表中加上一个数据版本号version字段，表示数据被修改的次数，当数据被修改时，version值会加一。当线程A要更新数据值时，在读取数据的同时也会读取version值，在提交更新时，若刚才读取到的version值为当前数据库中的version值相等时才更新，否则重试更新操作，直到更新成功。
核心SQL代码： update table set xxx=#{xxx}, version=version+1 where id=#{id} and version=#{version};

（2）CAS算法

（Check And Set【先检查再动手设置】）：CAS操作方式：即 compare and set，CAS是乐观锁技术，涉及到三个操作数，数据所在的内存值，预期值，新值。当需要更新时，判断当前内存值与之前取到的值是否相等，若相等，则用新值更新，若失败则重试，一般情况下是一个自旋操作，即不断的重试。

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

1.5、JAVA对CAS的支持：

在JDK1.5中新增java.util.concurrent包就是建立在CAS之上的。相对于synchronized这种阻塞算法，CAS是非阻塞算法的一种常见实现。所以java.util.concurrent包中的AtomicInteger为例，看一下在不使用锁的情况下是如何保证线程安全的。主要理解getAndIncrement方法，该方法的作用相当于++i操作。

public class AtomicInteger extends Number implements java.io.Serializable{ 　　private volatile int value; 　　public final int get(){ 　　　　return value; 　　} 　 public final int getAndIncrement(){ 　　　　for (;;){ 　　　　　　int current = get(); 　　　　　　int next = current + 1; 　　　　　　if (compareAndSet(current, next)) 　　　　　　return current; 　　　　} 　　} 　　public final boolean compareAndSet(int expect, int update){ 　　　　return unsafe.compareAndSwapInt(this, valueOffset, expect, update); 　　} }

2、悲观锁（Pessimistic Lock）：

2.1、介绍

很悲观，认为什么时候都会出现问题，无论做什么都会加锁，别人想拿这个数据就会阻塞直到它拿到锁。

从广义上来讲，（数据库）行锁&表锁、读锁、写锁、共享锁、排他锁等，这些都属于悲观锁范畴。

2.2、优缺点

优点：可以保证数据的独占性和正确性；

缺点：每次请求都需要加锁、释放锁，这个过程会降低系统性能。

2.3、使用场景：

悲观锁适合写多读少，悲观锁在Java中的使用，就是利用各种锁。

比如Java里面的同步原语synchronized关键字的实现就是悲观锁；传统的关系型数据库里边就用到了很多这种锁机制，比如行锁、表锁，读锁，写锁等，都是在操作之前先上锁

2.4、使用方法：

  在对任意记录进行修改前，先尝试为该记录加上排他锁（exclusive locking）。

 如果加锁失败，说明该记录正在被修改，那么当前查询可能要等待或者抛出异常。具体响应方式由开发者根据实际需要决定。

 如果成功加锁，那么就可以对记录做修改，事务完成后就会解锁了。

 期间如果有其他对该记录做修改或加排他锁的操作，都会等待我们解锁或直接抛出异常。

二、独享锁/共享锁：

1、 独享锁

  也叫排他锁，是指该锁一次只能被一个线程所持有；不能与其他锁并存，即当前写操作没有完成前，会阻断其他写锁和读锁。

2、共享锁

是指该锁可被多个线程所持有，多个事务对于同一数据共享一把锁，都能访问到数据，但是只能读不能修改。

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

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

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

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

三、互斥锁/读写锁：

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

四、可重入锁：

可重入锁又名递归锁，是指在同一个线程在外层方法获取锁的时候，在进入内层方法会自动获取锁。简单来说就是同一个线程可以重复加锁，每次加锁的时候count值加1，每次释放锁的时候count减1，直到count为0，其他的线程才可以再次获取。对于Java ReetrantLock而言，从名字就可以看出是一个重入锁，其名字是Re entrant Lock 重新进入锁。对于Synchronized而言，也是一个可重入锁。可重入锁的一个好处是可一定程度避免死锁。如：

synchronized void setA() throws Exception{ 　　Thread.sleep(1000); 　　setB(); } synchronized void setB() throws Exception{ 　　Thread.sleep(1000); }

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

五、公平锁/非公平锁：

公平锁是指多个线程按照申请锁的顺序来获取锁。非公平锁是指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程比先申请的线程优先获取锁。有可能，会造成优先级反转或者饥饿现象。对于Java ReetrantLock而言，通过构造函数指定该锁是否是公平锁，默认是非公平锁。非公平锁的优点在于吞吐量比公平锁大。对于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。