多线程（3）：Java线程同步机制中的高级应用

最新推荐文章于 2023-04-06 21:51:20 发布

Hey 锡瑞

最新推荐文章于 2023-04-06 21:51:20 发布

阅读量264

点赞数

分类专栏：多线程文章标签： CAS与原子变量 AQS原理 CAS算法并发框架Disruptor

本文链接：https://blog.csdn.net/RuiKe1400360107/article/details/103125785

版权

多线程专栏收录该内容

10 篇文章 1 订阅

订阅专栏

一.CAS与原子变量

1.1、原子类Atomic

原子类底层使用 CAS无锁技术实现线程安全，面试时谈CAS得先谈Java内存模型

（1）什么是原子类

具有原子/原子操作特征的类

并发包 java.util.concurrent（J.U.C） 的原子类都存放在java.util.concurrent.atomic下

（2）JUC包中的原子类是哪四类

基本类型——使用原子的方式更新基本类型：

AtomicInteger：整形原子类
AtomicLong：长整型原子类
AtomicBoolean：布尔型原子类

数组类型——使用原子的方式更新数组里的某一个元素：

AtomicIntegerArray：整形数组原子类
AtomicLongArray：长整形数组原子类
AtomicReferenceArray：引用类型数组原子类

引用类型

AtomicReference：引用类型原子类
AtomicStampedReference：原子更新引用类型里的字段原子类
AtomicMarkableReference ：原子更新带有标记位的引用类型

对象的属性修改类型

AtomicIntegerFieldUpdater：原子更新整形字段的更新器
AtomicLongFieldUpdater：原子更新长整形字段的更新器
AtomicStampedReference：原子更新带有版本号的引用类型。该类将整数值与引用关联起来，可用于解决原子的更新数据和数据的版本号，可以解决使用 CAS 进行原子更新时可能出现的 ABA 问题

1.2、常用原子类AtomicInteger（整形原子类）介绍

（1）AtomicInteger 类的底层原理

部分源码：

  // setup to use Unsafe.compareAndSwapInt for updates（更新操作时提供“比较并替换”的作用）
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private static final long valueOffset;

    static {
        try {
            valueOffset = unsafe.objectFieldOffset
                (AtomicInteger.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }

    private volatile int value;

原理：AtomicInteger 类主要利用CAS（compare and swap，比较并交换）+volatile+native方法保证原子操作，从而避免synchronized 高开销，提升了效率

（2）AtomicInteger 类的常用方法

public final int get() //获取当前的值
public final int getAndSet(int newValue)//获取当前的值，并设置新的值
public final int getAndIncrement()//获取当前的值，并自增
public final int getAndDecrement() //获取当前的值，并自减
public final int getAndAdd(int delta) //获取当前的值，并加上预期的值
boolean compareAndSet(int expect, int update) //如果输入的数值等于预期值，则以原子方式将该值设置为输入值（update）
public final void lazySet(int newValue)//最终设置为newValue,使用 lazySet 设置之后可能导致其他线程在之后的一小段时间内还是可以读到旧的值。

（3）为什么要用AtomicInteger 原子类

多线程情下对java中的运算操作若没有进行同步情况下，比如自增或者自减，是线程不安全的

（4） AtomicInteger 类的使用示例

使用AtomicInteger之后，不用对increment()方法加锁也可以保证线程安全：

class AtomicIntegerTest {
        private AtomicInteger count = new AtomicInteger();
      //使用AtomicInteger之后，不需要对该方法加锁，也可以实现线程安全。
        public void increment() {
      //incrementAndGet()方法在一个无限循环体内，不断尝试将一个比当前值大1的新值赋给自己（每次自增i++）
                  count.incrementAndGet();//(采用乐观锁，CAS无锁机制，线程安全)
        }
       public int getCount() {
                return count.get();
        }
}

1.3、CAS（比较并交换）

什么是CAS：

jdk1.5增加了并发包java.util.concurrent.*，其下面的类使用CAS算法实现，是区别于synchronouse同步锁的一种乐观锁

1.CAS原理（CAS无锁机制——但是属于乐观锁、自旋锁）

拿着期望的值与原本的值进行比较，如果相同则更新为新的值。

UnSafe类的objectFieIdOffset()方法是一个本地方法，用来拿到“原来的值”的内存地址，返回是valueOffset。value是一个volatile变量，在内存中可见。因此JVM可以保证任何时刻任何线程总能拿到该变量最新的值。

2.使用CAS之前了解2种锁思想：悲观锁和乐观锁

悲观锁（适合多写）：总是设想最坏情况，每次拿数据都认为别人会修改，所以每次拿数据都会上锁。比如关系型数据库就用了这种锁机制，比如行锁、表锁、读锁、写锁等。都是在操作之前先上锁；还有java中synchronized和ReentrantLock都是悲观锁思想。

乐观锁（适合多读）：总是设想最好情况，每次拿数据都认为别人不会修改，所以不会上锁。但是在更新时候会判断一下在此期间别人有没有去更新这个数据（使用版本号和CAS算法实现）。

当多个线程同时使用CAS操作一个变量时，只有一个会胜出，并成功更新，其余均会失败，失败的线程不会被挂起，仅是被告知失败，并且允许再次尝试，所以没有锁，也可以防止其他线程对当前线程的干扰。

适合多读场景，比如java中原子变量类就是使用乐观锁实现方式CAS实现。

（通俗的理解：自己给个期望值，就是你认为这个变量应该咋样的。如果不是你想那样，说明已经被修改过了。重新读取再次尝试修改就好了）

3.乐观锁2种实现方式：版本号机制、CAS算法

（1）版本号机制（version方式）原理

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

核心SQL语句：

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

说明：

如果能够使用到版本（version和id）如果能查到——之前没有改过；

如果能够使用到版本（version和id）查不到——版本已经发生改变。

（2）CAS算法（比较与交换算法）原理

是一种无锁算法。即不需要加锁情况下实现多线程之间的变量同步。因为是在没有现成被阻塞情况下实现变量的同步，所以也叫非阻塞同步。CAS算法设计三个参数：

需要读写的内存值 V（需要更新的变量值）——主内存值
进行比较的值 A（期望值）——本地内存值
拟写入的新值 B（新值）

当且仅当V的值等于A时（主内存值与本地内存值一致，说明：没有被修改过），CAS通过原子方式用新值B来更新V的值，入过 V！=A 则不会执行任何操作。是一个自旋操作（也是自旋锁），即不断重试。

深入理解自旋锁推荐阅读：https://blog.csdn.net/qq_34337272/article/details/81252853

4.乐观锁的缺点 / 乐观锁可能导致的问题

（1）ABA问题

如果一个变量V初次读取的时候是A值，并且在准备赋值的时候检查到它仍然是A值，那就可以说明它的值没有被其他线程修改过了吗？显然不能，有可能被改过又被改回了，但是CAS会误认为它从来没被改过，这就是"ABA问题"。

解决办法：使用AtomicStampedReference 的compareAndSet() 方法，首先检查当前引用是否等于预期引用，并且当前标志是否等于预期标志，如果全部相等，则以原子的方式将该引用和标志值设置为给定的新值。

（2）循环时间长开销大

自旋CAS如果长时间不成功会给CPU造成压力。

（3）只能保证一个共享变量的原子操作

CAS只对单个共享变量有效。当操作跨多个共享变量时CAS无效。

解决办法：AtomicReference类保证引用对象之间的原子性，可以把多个变量放在一个对象里面进行CAS操作。也就是说可以使用锁或者 AtomicReference类把多个变量合并成一个共享变量来操作。

二.AQS

2.1、AQS介绍/什么是AQS

AQS的全称为（AbstractQueuedSynchronizer），这个类在java.util.concurrent.locks包下面。

AQS是一个用来构建锁和同步器的框架，使用AQS能简单高效地构造出大量同步器（比如ReentrantLock、Semaphore、ReentrantReadWriteLock、SynchronousQueue、FutureTask）

2.2、AQS原理

AQS的核心思想是，如果被请求的共享资源空闲，则将当前请求资源的线程设置为有效工作线程，并且共享资源设置为锁定状态；

如果被请求的共享资源被占用，就需要一套机制去执行阻塞等待，然后执行线程被唤醒时的锁分配，将展示获取不到锁的线程加入等待队列中。这套机制就是AQS，它是一个用来构建锁和同步器的框架，而AQS是用CLH队列锁(先进先出FIFO)实现：

CLH（队列锁）:是一个虚拟的双向队列，既不存在的队列实例，仅存在节点之间的关联关系，AQS里面的CLH队列是CLH同步锁的一种变形。AQS是将每条请求共享资源的线程都封装成一个CLH锁队列的一个节点，来实现锁的分配。

AQS使用一个int成员变量来表示同步状态，通过内置FIFO队列来完成获取资源线程的排队工作。AQS使用CAS对该同步状态进项原子操作实现对其值的修改。部分源码分析如下：

//共享变量，表示同步状态，使用volatile修饰保证线程可见性
private volatile int state;
//状态信息通过protected类型的getState，setState，compareAndSetState进行操作
//返回同步状态的当前值
protected final int getState() {  
        return state;
}
 // 设置同步状态的值
protected final void setState(int newState) { 
        state = newState;
}
//原子地（CAS操作）将同步状态值设置为给定值update如果当前同步状态的值等于expect（期望值）
protected final boolean compareAndSetState(int expect, int update) {
        return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}

如下是AQS原理图：

AQS原理图

深入了解CLH访问这篇博客：https://www.cnblogs.com/chenssy/p/5087652.html

2.3、AQS对资源的共享方式（2种）

（1）Exclusive（独占）

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

公平锁：按照线程在队列中的排队，先到者先拿到锁

非公平锁：线程获取锁时，谁抢到就是谁的

（2）Share（共享）

多个线程可同时进行

2.4、AQS的各个组件介绍

（1）Semaphore（信号量）——允许多个线程同时访问

synchronized 和 ReentrantLock都是一次只能允许一个线程访问。访问某个资源，Semaphore可以指定多个线程同时访问某个资源。

（2）CountDownLatch（倒计时器）：它是一个同步工具类，用来协调多个线程之间的同步，常用来控制线程等待。它可以让某个线程等待直到倒计时器结束，再开始执行。

（3）CylicBarrier（循环栅栏）：和CountDownLatch类似，但比它强大。

2.5、AQS你是怎么使用的？

首先需要继承AbstractQueuedSynchronizer类，然后根据需求重写相应方法。（比如要实现一个独占锁，就重写tryAcquire、tryRelease；要实现共享锁，就去重写tryAcquireShared，tryReleaseShared；最后在组件中调用AQS的模板方法就可以了，这些模板方法会调用之前重写的那些方法）。只需要很小的工作量就可实现同步组件，重写的那些方法仅仅是一些对共享资源state的获取和释放操作。

深入理解AQS推荐这篇博客：https://www.cnblogs.com/chengxiao/archive/2017/07/24/7141160.html

三、并发框架Disruptor（了解）

官网译文：http://ifeve.com/disruptor-getting-started/

美团的文档：https://tech.meituan.com/2016/11/18/disruptor.html

3.1、什么是Disruptor

Disruptor是一个高性能的异步处理框架，能够在无锁情况下实现网络的Queue并发操作，底层使用的是CAS无锁机制实现，能远远高于传统的BlockingQueue容器。可以理解为他是一种高效的"生产者-消费者"模型。

（BlockingQueue实现了生产者-消费者模型，但是他是基于锁实现的效率低，Disruptor使用CAS无锁机制也可实现生产者-消费者模型）

3.2、Disruptor实现原理

Disruptor使用观察者模式，主动将消息发送给消费者，而不是等小疯子和从队列中取；底层使用CAS算法在无锁情况下实现queue（环形RingBuffer数组）的并发操作，性能远高于BlockingQueue

3.3、Disruptor的设计方案

通过以下设计来解决队列速度慢的问题：

（1）环形数组结构：为了避免GC垃圾回收，采用数组而非链表，数组对处理器的缓存机制更加友好

（2）元素位置定位

（3）无锁设计

### 若对你有帮助的话，欢迎点赞！评论！转发！谢谢！

上一篇：锁

下一章：Java线程同步机制中的锁优化以及线程池技术

参考资料：《Java多线程编程实战指南-核心篇》.黄文海.豆瓣.8.7分

参考资料：《深入理解Java虚拟机第二版》.周志明.豆瓣.8.6分

参考资料：《java并发编程实战》https://www.cnblogs.com/chenssy/p/5087652.html

参考资料：https://github.com/Snailclimb/JavaGuide

参考资料：https://blog.csdn.net/fanrenxiang/article/details/80623884

Hey 锡瑞

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
多线程（3）：Java线程同步机制中的高级应用

一.CAS与原子变量1.1、原子类Atomic原子类底层使用 CAS无锁技术实现线程安全，面试时谈CAS得先谈Java内存模型（1）什么是原子类具有原子/原子操作特征的类并发包java.util.concurrent（J.U.C）的原子类都存放在java.util.concurrent.atomic下（2）JUC包中的原子类是哪四类基本类型——使用原子的方式更新基...
复制链接

扫一扫