六、锁的深入化

1.锁的分类

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

1.1 公平锁/非公平锁

1.1.1 公平锁

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

1.1.2 非公平锁

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

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

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

1.2 可重入锁/不可重入锁

1.2.1 可重入锁

• 广义上的可重入锁指的是可重复，可递归调用的锁，在外层使用锁之后，在内层仍然可以使用，并且不发生死锁（前提是同一个对象或者class）

ReentrantLock 和 synchronized 都是可重入锁。

1.2.2 不可重入锁

• 与重入锁相反，不可递归调用，递归调用就会发生死锁。

1.3 独享锁/共享锁

1.3.1 独享锁

• 该锁每一次只能被一个线程所持有的。

1.3.2 共享锁

• 该锁可被多个线程共有，典型的就是ReentrantReadWriteLock里的读锁，它的读锁是可以被共享的，但是它的写锁每次只能被独占。

另外，读锁的共享可保证并发读诗非常高效的，但是读写和写写，写读都是互斥的。

独享锁与共享锁也是通过 AQS 来实现的。

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

1.4 互斥锁/读写锁

1.4.1 互斥锁

• 在访问共享资源之前进行加锁操作，在访问完成之后进行解锁操作。加锁后，任何其他试图再次加锁的线程会被阻塞，直到当前线程解锁。

1.4.2 读写锁

• 读写锁既是互斥锁，又是共享锁，read模式是共享，write是互斥。

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

1.5 乐观锁/悲观锁

1.5.1 悲观锁

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

传统的关系型数据库里边就用到了很多这种锁机制，比如行锁、表锁。读锁、写锁等，都是在做操作之前先上锁。Java中 synchronized 和 ReentrantLock 等独占锁就是悲观锁思想的实现。

1.5.2 乐观锁

• 总是假设最好的情况，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号机制和CAS算法实现。

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

在Java中,java.util.concurrent.atomic包下面的原子变量类就是使用乐观锁的一种实现方式CAS。

1.6 分段锁

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

容器里有多把锁，每一把锁用于锁容器其中一部分数据，那么当多线程访问容器里不同数据段的数据时，线程间就不存在锁竞争，从而有效的提高并发访问效率，这就是ConcurrentHashMap所使用的锁分段技术。

1.7 偏向锁/轻量级锁/重量级锁

synchronized 锁的状态：

• 无锁状态
• 偏向锁状态
• 轻量级锁状态
• 重量级锁状态

锁的状态是通过对象监视器在对象头中的字段来表明的。

四种状态会随着竞争的情况逐渐升级，而且是不可逆的过程，即不可降级。

这四种状态都不是Java语言中的锁，而是JVM为了提高锁的获取与释放而做的优化（使用synchronized时）

1.7.1 偏向锁

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

1.7.2 轻量级锁

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

1.7.3 重量级锁

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

1.8 自旋锁

1.8.1 CAS: 无锁的执行者：Compare And Swap

无锁的好处：

• 1.在高并发的情况下，它比有锁的程序拥有更好的性能。
• 2.它天生就是死锁免疫的。

凭借这两个优势，就值得我们冒险尝试使用无锁的并发。

CAS算法的核心思想：

• 执行函数 CAS(V, E, N);

其包含3个参数：
V：表示要更新的变量
E：表示预期值
N：表示新值

如果V值等于E值，则将V的值设为N。若V值和E值不同，则说明已经有其他线程做了更新，则当前线程什么都不做。

由于CAS操作属于乐观锁，它总认为自己可以完成操作，当多个线程同时使用CAS操作一个变量时，只有一个会胜出，并成功更新，其余均会失败，但失败的线程并不会被挂起，仅是被告知失败，并且允许再次尝试，当然也允许失败的线程放弃操作。

基于这样的原理，CAS操作即使没有锁，同样知道其他线程对共享资源操作影响，并执行相应的处理措施。

CPU指令对CAS的支持：

• 或许我们可能会有这样的疑问，假设存在多个线程执行CAS操作，并且CAS的步骤很多，有没有可能在判断V和E相同后，正要赋值时，切换了线程，更改了值，造成了数据不一致呢？答案是否定的。因为CAS是一种系统原语，原语属于操作系统用语范畴，是由若干条指令组成的，用于完成某个功能的一个过程，并且原语的执行必须是连续的，在执行过程中不允许被中断。

1.8.2 鲜为人知的指针:Unsafe类

Unsafe类存在于sun.misc包中，其内部方法操作可以像C的指针一样直接操作内存，该类是非安全的，毕竟unsafe拥有着类似于C的指针操作，因此总是不应该首先使用Unsafe类。

但是我们还是有必要了解该类，因为Java中CAS操作的执行依赖于Unsafe类的方法，注意Unsafe类中的所有方法都是native修饰的。

public class User{
  public User(){
    sysout("User构造方法被调用");

    private String name;

    private int age;

    private static String id = "USER_ID";

    @override
    public String toString(){
      return "User{ name + age + id}"
    }
  }
}

public class UnsafeDemo{
  public static void main(String[] args){
    // 通过反射得到Unsafe类中的theUnsafe对象
    Field field = Unsafe.class.getDeclaredFiled("theUnsafe");

    // 设置该Field为可访问
    field.setAccessible(true);

    // 通过该Field得到对应的具体对象
    // 如果不是static属性，那么get方法的参数就不能是null,否则会抛出异常
    // 如果是static属性，那么传入任何对象包括null,因为get方法会将该参数忽略
    Unsafe unsafe = (Unsafe) field.get(null);

    sysout(unsafe);

    // 通过allocateInstance直接创建对象，不会调用构造方法
    User user = (User) unsafe.allocateInstance(User.class);

    Class userClass = user.getClass();

    Field name = userClass.getDeclaredField("name");

    Field age = userClass.getDeclaredField("age");

    Field id = userClass.getDeclaredField("id");

    // 获取实例变量name和age在对象内存中的偏移量并设置值
    unsafe.putInt(user, Unsafe.objectFieldOffset(age), 18);

    unsafe.putObject(user, Unsafe.objectFieldOffset(name), "android-TV");

    // 这里返回User.class
    Object staticBase = Unsafe.staticFieldBase(id);

    sysout("staticBase:" + staticBase);

    // 获取静态变量id的偏移量StaticOffset
    long staticOffset = unsafe.staticFieldOffset(userClass.getDeclaredField("id"));

    // 获取静态变量的值
    sysout("设置前的ID:" + unsafe.getObject(staticBase, staticOffset));

    // 设置值
    unsafe.putObject(staticBase, staticOffset, "sss");

    sysout("设置后的ID:" + unsafe.getObject(staticBase, staticOffset));

    // 输出User
    sysout("输出USER:" + user.toString());

    sysout("--------------------");

    long data = 1000;

    byte size = 1;

    // 调用allocateMemory分配内存，并获取内存地址memoryAddress
    long memoryAddress = Unsafe.allocateMemory(size);

    // 直接往内存写入数据
    Unsafe.putAddress(memoryAddress, data);

    // 获取指定内存地址的数据
    long addressData = Unsafe.getAddress(memoryAddress);
    sysout("addrData：" + addrData);
  }
}

虽然在Unsafe类中存在getUnsafe()方法，但该方法只提供给高级的Bootstrap类加载器使用，普通用户调用将抛出异常。所以我们在Demo中使用了反射技术获取了Unsafe实例对象并进行相关操作。

1.8.3 CAS操作相关

CAS是一些CPU直接支持的指令，也就是我们前面分析的无锁操作，在Java中无锁操作CAS基于以下3个方法实现：

// 第一个参数o为给定对象，offset为对象内存的偏移量，通过这个偏移量迅速定位字段并设置或获取该字段的值。
// expected表示期望值，x表示要设置的值，下面3个方法都通过CAS原子指令进行操作
public final native boolean compareAndSwapObject(Object o, long offset, Object expected, Object x);

public final native boolean compareAndSwapInt(Object o, long offset, int expected, int x);

public final native boolean compareAndSwapInt(Object o, long offset, long expected, long x);

1.9 CAS在Java中的应用

1.9.1 原子更新基本类型

• AtomicBoolean
• AtomicInteger
• AtomicLong

这3个类的实现原理和使用方式几乎是一样的，这里我们以AtomicInteger为例，进行分析。

AtomicInteger 主要针对int类型的数据执行原子操作，它提供了原子自增方法，原子自减方法以及原子赋值方法。

实现原理:

public class AtomicInteger extends Number implements java.io.Serializable{

  // 获取指针类Unsafe
  private static final Unsafe unsafe = Unsafe.getUnsafe();

  // 变量value在atomicInteger实例变量内的内存偏移量
  private static final long valueOffset;

  static {
      try {
          // 通过Unsafe类的objectFieldOffset方法，获取value变量在对象
          // 内存中的偏移
          // 通过该偏移量valueOffset，unsafe类的内部方法可以获取到变量
          // value并对其进行取值或者赋值操作
          valueOffset = unsafe.objectFieldOffset
              (AtomicInteger.class.getDeclaredField("value"));
      } catch (Exception ex) { throw new Error(ex); }
  }

  private volatile int value;

  /**
    * Creates a new AtomicInteger with the given initial value.
    *
    * @param initialValue the initial value
    */
  public AtomicInteger(int initialValue) {
      value = initialValue;
  }

  // 设置新值并获取旧值，底层调用的是CAS操作
  public final int getAndSet(int newValue) {
      return unsafe.getAndSetInt(this, valueOffset, newValue);
  }

  // 如果当前值为expect，则设置为update
  public final boolean compareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
  }

  // 当前值加1，返回旧值，底层CAS操作
  public final int getAndIncrement() {
        return unsafe.getAndAddInt(this, valueOffset, 1);
  }

  // 当前值加1，返回新值
  public final int incrementAndGet() {
        return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
  }
}

Unsafe类中的getAndAddInt方法：

public final int getAndAddInt(Object o, long offset, int delta){
  int v;
  do:
    v = getIntVolatile(o, offset);
  while(!compareAndSwapInt(o, offset, v, v + delta))
  return v;
}

可以看出,getAndAddInt通过while循环不断的重试，更新要设置的值，直到成功为止。

使用方式：

public class AtomicIntegerDemo{
  static AtomicInteger i = new AtomicInteger();

  public static class AddThread implements Runnable{
    @override
    public void run(){
      for(int k = 0; k < 10000; k++){
        i.incrementAndGet();
      }
    }
  }

  public static void main(String[] args){
    Thread[] ts = new Thread[10];
    for(int k = 0; k < 10; k++){
      ts[k] = new Thread(new AddThread());
    }

    for(int k = 0; k < 10; k++){
      ts[k].join();
    }

    sysout(i);
  }
}

1.9.2 原子更新引用

• AtomicReference

使用方式：

public class AtomicReferenceDemo{
  public static AtomicReference<User> atomicUserRef = new AtomicReference<User>();

  public static void main(String[] args){
    User user = new User("zejian", 18);
    atomicUserRef.set(user);

    User updateUser = new User("shine", 25);
    atomicUserRef.compareAndSet(user, updateUser);
    sysout(atomicUserRef.get().toString());
  }

  static class User{
    public String name;
    private int age;
  }
}

1.9.3 原子更新数组：

原子更新数组指的是通过原子的方式更新数组中的某个元素

• AtomicIntegerArray
• AtomicLongArray
• AtomicReferenceArray

使用方式：

public class AtomicIntegeArrayDemo{

  static AtomicIntegeArray arr = new AtomicIntegeArray(10);

  public static class AddThread implements Runnable:
    run():
      for(int k = 0; k < 10000; k++){
        arr.getAndIncrement(k % arr.length);
      }
  main():
    Thread ts = new Thread[10];
    for(k:0-10, k++): ts[k] = new Thread(new AddThread());
    for(k:0-10, k++): ts[k].start();
    for(k:0-10, k++): ts[k].join();
    sysout(arr);
}

2.0 CAS的ABA问题及解决方案

假设，当第一个线程执行CAS(V, E, U)操作，在获取到当前变量V，准备修改为新值U前，另外两个线程已经连续修改了两次变量V的值，使得该值又恢复为旧值，这样的话，我们就无法正确判断这个变量是否已经被修改过。

这就是典型的CAS的ABA问题，一般这种情况发生的概率较小，可能发生了改变也不会造成什么问题，但是在某些情况下还是需要防止的。

在Java中解决ABA问题，可以使用以下两个原子类：

• AtomicStampedReference

AtomicStampedReference 原子类是一个带有时间戳的对象引用，在每次修改后，AtomicStampedReference不仅会设置新值，而且还会记录更改的时间。

当 AtomicStampedReference 设置对象值时，对象值以及时间戳必须满足期望值才能写入成功。

测试Demo如下:

package com.zava.multithread.cas;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicStampedReference;

public class ABADemo {

	public ABADemo() {
	}
	
	static AtomicInteger atIn = new AtomicInteger(100);
	
  // 初始化时需要传入一个初始值和初始时间
	static AtomicStampedReference<Integer> atomicStampedR = new AtomicStampedReference<Integer>(100, 0);
	
	static Thread t1 = new Thread(new Runnable() {
		
		public void run() {
			
			atIn.compareAndSet(100, 200);
			
			atIn.compareAndSet(200, 100);
			
		};
	});
	
	static Thread t2 = new Thread(new Runnable() {
		
		@Override
		public void run() {
			try {
				TimeUnit.SECONDS.sleep(1);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			
			boolean flag = atIn.compareAndSet(100, 500);
			
			System.out.println("flag:" + flag + ",newValue:" + atIn);
		}
	});
	
	static Thread t3 = new Thread(new Runnable() {
		
		@Override
		public void run() {
			int time = atomicStampedR.getStamp();
			
			System.out.println(Thread.currentThread().getName() + "-time:" + time);
			
			boolean flag1 = atomicStampedR.compareAndSet(100, 200, time, time + 1);
			
			System.out.println("------flag1---------" + flag1);
			
//			int time2 = atomicStampedR.getStamp();
//			
//			System.out.println(Thread.currentThread().getName() + "-time2:" + time2);
			
			boolean flag2 = atomicStampedR.compareAndSet(200, 100, atomicStampedR.getStamp(), atomicStampedR.getStamp() + 1);
			
			System.out.println("------flag2---------" + flag2);
		}
	});
	
	static Thread t4 = new Thread(new Runnable() {
		
		@Override
		public void run() {
			int time = atomicStampedR.getStamp();
			
			System.out.println("sleep 前 t4 time:" + time);
			
			try {
				TimeUnit.SECONDS.sleep(1);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			
			boolean flag = atomicStampedR.compareAndSet(100, 500, time, time + 1);
			
			System.out.println("flag:" + flag + ",newValue:" + atomicStampedR.getReference());
		}
	});
	
	public static void main(String[] args) throws Exception {
		t1.start();
		t2.start();
		
		t1.join();
		
		t2.join();
		
		t3.start();
		
//		t4.start();
		
	}

}

输出结果:
flag: true,newValue:500
sleep钱 t4 time:0
flag: false, newValue:500

经典问题：请问flag1和flag2是多少？

static AtomicStampedReference<Integer> atomicStampedR = new AtomicStampedReference<Integer>(100, time);
boolean flag1 = atomicStampedR.compareAndSet(100, 200, time, time + 1); // true
boolean flag2 = atomicStampedR.compareAndSet(200, 100, time, time + 1); // false
// Integer.valueOf(100),Integer.valueOf(200)
// Integer缓存的是-127-128，所以flag2无法修改成功，虽然时间戳期待是一样的。

2.1 再来谈自旋锁

自旋锁：指当一个线程在获取锁的时候，如果锁已经被其他线程获取，那么该线程将循环等待，然后不断的判断锁是否能够被成功获取，直到获取到锁才会退出循环。

无论是互斥锁，还是自旋锁，在任何时刻，最多只能有一个保持者，但是两者在调度机制上略有不同。对于互斥锁，如果资源已经被占用，资源申请者只能进入等待状态，但是自旋锁不会，如果自旋锁已经被别的执行单元保持，调用者就一直循环在那里看是否该自旋锁的保持者已经释放锁。

Java实现自旋锁：

public class SpinLock{
  private AtomicReference<Thread> cas = new AtomicReference<>();

  public void lock(){
    Thread current = Thread.currentThread();
    while(!cas.compareAndSet(null, current)){

    }
  }

  public void unlock(){
    Thread current = Thread.currentThread();
    cas.compareAndSet(current, null);
  }
}

lock()方法利用CAS，当第一个线程A获取到锁的时候，能够成功获取到，不会进入while循环，如果此时线程A没有释放锁，另一个线程B又来获取锁，此时，由于不满足CAS，所以就会进入while循环，不断判断是否满足CAS，知道A线程调用unlock方法释放了锁

自旋锁存在的问题：

• 1.如果某个线程持有锁的时间过长，就会导致其他等待获取锁的线程进入循环等待，消耗CPU，使用不当会造成CPU使用率极高。

• 2.上面Java实现的自旋锁是不公平的，即无法满足等待时间最长的线程优先获取到锁。不公平的锁就会存在“线程饥饿”问题。

自旋锁的优点：
自旋锁不会使线程状态发生切换，一直处于用户状态，即线程一直都是active的；不会使线程进入阻塞状态，减少了不必要的上下文切换，执行速度快。

可重入的自旋锁：

public class ReentrantSpinLock {

    private AtomicReference<Thread> cas = new AtomicReference<>();

    private int count;

    public void lock() {
        Thread current = Thread.currentThread();

        if (current == cas.get()) {
            count++;
            return;
        }
        while (!cas.compareAndSet(null, current)) {

        }
    }

    public void unlock() {
        Thread cur = Thread.currentThread();
        if (cur == cas.get()) {
            if (count > 0) {
                count--;
            } else {
                cas.compareAndSet(cur, null);
            }
        }
    }
}