• Java性能 -- CAS乐观锁

    synchronized / Lock / CAS

    1. synchronized和Lock实现的同步锁机制，都属于悲观锁，而CAS属于乐观锁
    2. 悲观锁在高并发的场景下，激烈的锁竞争会造成线程阻塞，而大量阻塞线程会导致系统的上下文切换，增加系统的性能开销

    乐观锁

    1. 乐观锁：在操作共享资源时，总是抱着乐观的态度进行，认为自己能够完成操作
    2. 但实际上，当多个线程同时操作一个共享资源时，只有一个线程会成功，失败的线程不会被挂起，仅仅只是返回
    3. 乐观锁相比于悲观锁来说，不会带来死锁、饥饿等活性故障问题，线程间的相互影响也远远比悲观锁要小
      • 乐观锁没有因竞争而造成的系统上下文切换，所以在性能上更胜一筹

    实现原理

    1. CAS是实现乐观锁的核心算法，包含3个参数：V（需要更新的变量），E（预期值）、N（最新值）
    2. 只有V等于E时，V才会被设置为N
    3. 如果V不等于E了，说明其它线程已经更新了V，此时该线程不做操作，返回V的真实值

    CAS实现原子操作

    AtomicInteger是基于CAS实现的一个线程安全的整型类，Unsafe调用CPU底层指令实现原子操作

    1
    2
    3
    4
    5
    6
    7
    8
    		 
    // java.util.concurrent.atomic.AtomicInteger
    public final int getAndIncrement() {
        return unsafe.getAndAddInt(this, valueOffset, 1);
    }

    public final int getAndDecrement() {
        return unsafe.getAndAddInt(this, valueOffset, -1);
    }
    		 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    		 
    // sun.misc.Unsafe
    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;
    }

    public native int     getIntVolatile(Object o, long offset);

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

    处理器实现原子操作

    1. CAS是调用处理器底层指令来实现原子操作的
    2. 处理器和物理内存之间的通信速度要远低于处理器间的处理速度，所以处理器有自己的内部缓存（L1/L2/L3）
    3. 服务器通常为多处理器，并且处理器是多核的，每个处理器维护了一块字节的缓存存，每个内核也维护了一块字节的缓存
      • 此时在多线程并发就会存在缓存不一致的问题，从而导致数据不一致
    4. 处理器提供了总线锁定和缓存锁定两种机制来保证复杂内存操作的原子性
      • 总线锁定
        • 当处理器要操作一个共享变量时，会在总线上会发出一个Lock信号，此时其它处理器就不能操作共享变量了
        • 总线锁定在阻塞其他处理器获取该共享变量的操作请求时，也可能会导致大量阻塞，从而增加系统的性能开销
      • 缓存锁定（后来出现）
        • 当某个处理器对缓存中的共享变量进行了操作，就会通知其他处理器放弃存储或者重新读取该共享变量
        • 目前最新的处理器都支持缓存锁定机制

    优化CAS乐观锁

    1. 乐观锁在并发性能上要优于悲观锁
      • 但在写大于读的操作场景下，CAS失败的可能性增大，如果循环CAS，会长时间占用CPU
      • 例如上面的AtomicInteger#getAndIncrement
    2. JDK 1.8中，提供了新的原子类LongAdder
      • LongAdder在高并发场景下会比AtomicInteger和AtomicLong的性能更好，代价是消耗更多的内存空间
        • 核心思想：空间换时间
        • 实现原理：降低操作共享变量的并发数
      • LongAdder内部由一个base变量和一个cell[]数组组成
        • 当只有一个写线程（没有竞争）
          • LongAdder会直接使用base变量作为原子操作变量，通过CAS操作修改base变量
        • 当有多个写线程（存在竞争）
          • 除了占用base变量的一个写线程外，其他写线程的value值会分散到cell数组中
          • 不同线程会命中到数组的不同槽中，各个线程只对自己槽中的value进行CAS操作
          • value=base+∑ni=0Cell[i]value=base+∑i=0nCell[i]
      • LongAdder在操作后的返回值只是一个近似准确的值，但最终返回的是一个准确的值
        • LongAdder不适合实时性要求较高的场景

    性能对比

    1. 读大于写，读写锁ReentrantReadWriteLock、读写锁StampedLock、乐观锁LongAdder的性能最好
    2. 写大于读，乐观锁的性能最好，其他四种锁的性能差不多
    3. 读约等于写，两种读写锁和乐观锁的性能要优于synchronized和Lock

    小结

    1. 乐观锁的常见使用场景：数据库更新
      • 为每条数据定义一个版本号，在更新前获取版本号，在更新数据时，再判断版本号是否被更新过，如果没有才更新数据
    2. CAS乐观锁的使用比较受限，因为乐观锁只能保证单个变量操作的原子性
    3. CAS乐观锁在高并发写大于读的场景下
      • 大部分线程的原子操作会失败，失败后的线程将不断重试CAS原子操作，导致大量线程长时间占用CPU资源
      • JDK 1.8中，新增了原子类LongAdder，采用空间换时间的思路解决了这个问题，但实时性不高
     
  • 相关阅读:
    mysql教程（九） 索引详解
    mysql教程（八） 事务详解
    mysql教程（七） 约束详解
    mysql教程（七）创建表并添加约束
    mysql教程（六） 对字段的操作--添加、删除、修改
    mysql教程（五）limit的用法
    mysql教程（四）连接查询
    mysql教程（三）分组查询group by
    mysql教程（一）count函数与聚合函数
    mysql教程（二）数据库常用函数汇总
  • 原文地址：https://www.cnblogs.com/sevencutekk/p/11534117.html
Copyright © 2020-2023  润新知