Java原子类实现原理分析

已于 2024-07-08 18:07:46 修改
阅读量701 收藏 18
点赞数 25
分类专栏： 并发编程 文章标签： java 开发语言
于 2024-07-08 11:46:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hcjsjqjssm/article/details/140261306
版权

主要有两种实现，悲观锁和乐观锁实现方式.

悲观的解决方案（阻塞同步）

 我们知道，num++看似简单的一个操作，实际上是由1.读取 2.加一 3.写入 三步组成的，这是个复合类的操作（所以我们之前提到过的volatile是无法解决num++的原子性问题的），在并发环境下，如果不做任何同步处理，就会有线程安全问题。最直接的处理方式就是加锁。

synchronized(this){
    num++;
 }

使用独占锁机制来解决，是一种悲观的并发策略，每次操作数据的时候都认为别的线程会参与竞争修改，所以直接加锁。同一刻只能有一个线程持有锁，那其他线程就会阻塞。线程的挂起恢复会带来很大的性能开销，尽管jvm对于非竞争性的锁的获取和释放做了很多优化，但是一旦有多个线程竞争锁，频繁的阻塞唤醒，还是会有很大的性能开销的。所以，使用synchronized或其他重量级锁来处理显然不够合理。

方案一：ReentrantLock方式实现，100个并发任务基于10个线程执行，每个任务循环执行10次计数.

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockTest {
    private static int count = 0;
    private static final Lock CAS_LOCK=new ReentrantLock();

    private static final int JOB_NUM=100;

    private static final int THREAD_SIZE=10;

    private static void service() {
        CAS_LOCK.lock();
        try {
            count++;
            System.out.println("thread num execute:"+Thread.currentThread().getName()+":"+count);
        } finally {
            CAS_LOCK.unlock();
        }
    }

    public static void main(String[] args)  {
        ExecutorService executorService = Executors.newFixedThreadPool(THREAD_SIZE);
        CountDownLatch countDownLatch = new CountDownLatch(JOB_NUM);
        for(int i=0;i<JOB_NUM;i++){
            executorService.execute(new Runnable() {
                // 每个线程执行10次计算
                @Override
                public void run() {
                    for(int j=0;j<10;j++){
                        try {
                            service();
                        } finally {
                            countDownLatch.countDown();
                        }
                    }
                }
            });
        }
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        executorService.shutdown();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("get Count:"+count);
    }
}

 执行结果如下:

方案一：synchionized方式实现，100个并发任务基于10个线程执行，每个任务循环执行10次计数.

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ReentrantLockTest {
    private static volatile int count = 0;

    private static final int JOB_NUM=100;

    private static final int THREAD_SIZE=10;

    private static final byte[] lock=new byte[0];

    private static void service(){
        synchronized (lock){
            count++;
            System.out.println("thread num execute:"+Thread.currentThread().getName()+":"+count);
        }
    }

    public static void main(String[] args)  {
        ExecutorService executorService = Executors.newFixedThreadPool(THREAD_SIZE);
        CountDownLatch countDownLatch = new CountDownLatch(JOB_NUM);
        for(int i=0;i<JOB_NUM;i++){
            executorService.execute(new Runnable() {
                // 每个线程执行10次计算
                @Override
                public void run() {
                    for(int j=0;j<10;j++){
                        try {
                            service();
                        } finally {
                            countDownLatch.countDown();
                        }
                    }
                }
            });
        }
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        executorService.shutdown();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("get Count:"+count);
    }
}

运行截图

乐观的解决方案（非阻塞同步） 

乐观的解决方案，顾名思义，就是很大度乐观，每次操作数据的时候，都认为别的线程不会参与竞争修改，也不加锁。如果操作成功了那最好；如果失败了，比如中途确有别的线程进入并修改了数据（依赖于冲突检测），也不会阻塞，可以采取一些补偿机制，一般的策略就是反复重试。很显然，这种思想相比简单粗暴利用锁来保证同步要合理的多。

　　鉴于并发包中的原子类其实现机理都差不太多，本章我们就通过AtomicInteger这个原子类来进行分析。我们先来看看对于num++这样的操作AtomicInteger是如何保证其原子性的。

方案一：AtomicInteger方式实现，100个并发任务基于10个线程执行，每个任务循环执行10次计数.

package com.boot.skywalk;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;

public class ReentrantLockTest {
    private static AtomicInteger atomicInteger=new AtomicInteger(0);

    private static final int JOB_NUM=100;

    private static final int THREAD_SIZE=10;

    private static void service(){
        atomicInteger.getAndIncrement();
        System.out.println("thread num execute:"+Thread.currentThread().getName()+":"+atomicInteger.get());
    }

    public static void main(String[] args)  {
        ExecutorService executorService = Executors.newFixedThreadPool(THREAD_SIZE);
        CountDownLatch countDownLatch = new CountDownLatch(JOB_NUM);
        for(int i=0;i<JOB_NUM;i++){
            executorService.execute(new Runnable() {
                // 每个线程执行10次计算
                @Override
                public void run() {
                    for(int j=0;j<10;j++){
                        try {
                            service();
                        } finally {
                            countDownLatch.countDown();
                        }
                    }
                }
            });
        }
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        executorService.shutdown();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("get Count:"+atomicInteger.get());
    }
}

运行截图

 源码如下：

 /**
     * Atomically increments by one the current value.
     *
     * @return the updated value
     */
    public final int incrementAndGet() {
        for (;;) {
            int current = get();
            int next = current + 1;
            if (compareAndSet(current, next))
                return next;
        }
    }

我们来分析下incrementAndGet的逻辑：

　　1.先获取当前的value值

　　2.对value加一

　　3.第三步是关键步骤，调用compareAndSet方法来来进行原子更新操作，这个方法的语义是：先检查当前value是否等于current，如果相等，则意味着value没被其他线程修改过，更新并返回true。如果不相等，compareAndSet则会返回false，然后循环继续尝试更新。

compareAndSet调用了Unsafe类的compareAndSwapInt方法。

/**
     * Atomically sets the value to the given updated value
     * if the current value {@code ==} the expected value.
     *
     * @param expect the expected value
     * @param update the new value
     * @return true if successful. False return indicates that
     * the actual value was not equal to the expected value.
     */
    public final boolean compareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }

Unsafe的compareAndSwapInt是个native方法，也就是平台相关的。它是基于CPU的CAS指令来完成的。

public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);

CAS(Compare-and-Swap)

CAS算法是由硬件直接支持来保证原子性的，有三个操作数：内存位置V、旧的预期值A和新值B，当且仅当V符合预期值A时，CAS用新值B原子化地更新V的值，否则，它什么都不做。

　　CAS的ABA问题

　　当然CAS也并不完美，它存在"ABA"问题，假若一个变量初次读取是A，在compare阶段依然是A，但其实可能在此过程中，它先被改为B，再被改回A，而CAS是无法意识到这个问题的。CAS只关注了比较前后的值是否改变，而无法清楚在此过程中变量的变更明细，这就是所谓的ABA漏洞。 

CAS解决

使用AtomicStampedReference解决，带有版本号.

import com.google.common.collect.Lists;

import java.util.concurrent.atomic.AtomicStampedReference;

public class CodeTest {
    public static void main(String[] args) {
        // 初始化一个带版本号的原子操作类，原始值：a，原始版本号：1
        AtomicStampedReference<String> reference = new AtomicStampedReference<>("a", 1);
        // 将a更为b，同时将版本号加1，第一个参数：预期原值；第二个参数：更新后的新值；第三个参数：预期原版本号；第四个参数：更新后的版本号
        boolean result1 = reference.compareAndSet("a", "b", reference.getStamp(), reference.getStamp() + 1);
        System.out.println("第一次更新：" + result1);
        // 将b更为a，因为预期原版本号不对，所以更新失败
        System.out.println(reference.getStamp());
        boolean result2 = reference.compareAndSet("b", "a", 1, reference.getStamp());
        System.out.println("第二次更新：" + result2);
    }

CAS算法实现 

for(;;)：循环方式实现自旋 

public class IncrementExamplePositive {
    private volatile int num;
    // private int num;

    public void  incrementNum() {
        int current;
        int next;
        do {
            current = num; // 获取当前值
            next = current + 1; // 计算递增后的值
        } while (!compareAndSet(current, next)); // 比较并设置，知道成功递增
    }

    private boolean compareAndSet(int expect, int update) {
        if (num == expect) {
            num = update; // 设置新值
            return true;
        }
        return false;
    }

    public int getNum() {
        return num;
    }
}

 LongAddr

方案一：LongAddr方式实现，100个并发任务基于10个线程执行，每个任务循环执行10次计数.

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.LongAdder;

public class ReentrantLockTest {
    private static LongAdder adder=new LongAdder();

    private static final int JOB_NUM=100;

    private static final int THREAD_SIZE=10;

    private static void service(){
        adder.increment();
        System.out.println("thread num execute:"+Thread.currentThread().getName()+":"+adder.longValue());
    }

    public static void main(String[] args)  {
        ExecutorService executorService = Executors.newFixedThreadPool(THREAD_SIZE);
        CountDownLatch countDownLatch = new CountDownLatch(JOB_NUM);
        for(int i=0;i<JOB_NUM;i++){
            executorService.execute(new Runnable() {
                // 每个线程执行10次计算
                @Override
                public void run() {
                    for(int j=0;j<10;j++){
                        try {
                            service();
                        } finally {
                            countDownLatch.countDown();
                        }
                    }
                }
            });
        }
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        executorService.shutdown();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("get Count:"+adder.longValue());
    }
}

LongAdder是JDK1.8由Doug Lea大神新增的原子操作类，位于java.util.concurrent.atomic包下，LongAdder在高并发的场景下会比AtomicLong 具有更好的性能，代价是消耗更多的内存空间。

LongAdder是Google开源的一个高性能计数器实现。它采用了一种分段锁的策略，将一个long型的变量分割成多个16字节的段，每个段都使用一个独立的AtomicLong进行更新。这样，在高并发场景下，多个线程可以同时对不同的段进行更新操作，互不干扰。

LongAdder的优点是并发性能高，适用于高并发的场景。由于采用了分段锁的策略，LongAdder可以避免AtomicLong中的竞争问题。此外，LongAdder还支持可扩展性，可以通过增加更多的段来提高性能。但是，LongAdder的缺点是代码相对复杂一些，需要更多的维护成本。

LongAdder设计思想上，采用分段的方式降低并发冲突的概率。通过维护一个基准值base和 Cell 数组：

 

AtomicInteger的缺点：

图里可以看出在高并发情况下，当有大量线程同时去更新一个变量，任意一个时间点只有一个线程能够成功，绝大部分的线程在尝试更新失败后，会通过自旋的方式再次进行尝试，这样严重占用了CPU的时间片，进而导致系统性能问题。

高并发下推荐使用LongAdder的原因主要有以下几点：

  1. 高并发性能：LongAdder采用分段锁的策略，可以避免AtomicLong中的竞争问题，提高并发性能。在分布式系统中，高并发性能是非常重要的。
  2. 可扩展性：LongAdder支持可扩展性，可以通过增加更多的段来提高性能。这对于需要处理大量请求的分布式系统来说是非常有利的。
  3. 代码简单易懂：虽然LongAdder的代码相对复杂一些，但是相对于AtomicLong来说更容易理解和维护。这对于开发人员来说是非常重要的。
  4. 更好的适用场景：推荐使用LongAdder主要是因为在分布式系统中需要一个高性能、高可用的计数器实现。而LongAdder正好符合这个需求。
大道之简
关注
  • 25
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java中12个原子(Atomic)操作类实现原理分析
JavaShark的博客
05-31 1415
前言 我们知道i++操作实际上是线程不安全的，因为一个i++操作分为了三步： 1、获取的i的值 2、执行i+1 3、将i+1的结果赋值给i 而这三步不是一个原子操作，多线程环境下就会出现线程不安全性问题。 Java从JDK 1.5开始,在 java.util.concurrent.atomic包下提供了12个对应的原子类操作，让我们可以直接使用原子操作类来实现一个原子的i++操作。 Java中一共提供了12个原子类操作，可以分为四种类型，分别是： 原子更新基本类型 原子更新数组 原子更新引
「死磕Java并发编程」说说Java Atomic 原子类的实现原理
华科硕士，大厂打工中。编程问题咨询，请私我
06-11 1万+
<!-- TOC --> - [线程安全真的是线程的安全吗？](#线程安全真的是线程的安全吗) - [什么是 Atomic？](#什么是-atomic) - [实现一个计数器](#实现一个计数器) - [AtomicInteger 源码分析](#atomicinteger-源码分析) - [AtomicLong 和 LongAdder 谁更牛？](#atomiclong-和-longadder-谁更牛) - [总结](#总结) <!-- /TOC --> ..
Java中原子操作的实现原理
yygr的博客
01-19 145
原子操作就是不可被中断的一个或一系列操作，看看Java是怎么实现原子操作的。 CPU实现原子操作 处理器通过对总线加锁或者缓存行加锁的方式实现多个处理器之间的原子操作。 通过对总线加锁实现原子性，现在都是多处理器，对于共享变量的读写操作，如果不加限制，可导致数据的不一致，比如处理器把值改成A，另外的处理器又把值改成B，导致不是我们需要的结果。为了解决这个问题，处理器可以使用总线锁，当一个处理器锁住总线的时候，其他处理器处于阻塞状态。这样能解决问题，但是代价是很大的。 通过对缓存行加锁实现原子性，为了保证原
Java16个原子类介绍
GSON的博客
10-02 7982
关于原子类个数说明 在JDK7包括7之前，java原子类有12个，图片如下 在JDK8时出现了4个原子操作类，分别是如下图片所示 原子更新基本类型类 使用原子的方式更新基本类型，Atomic包提供了以下3个类。 AtomicBoolean: 原子更新布尔类型。 AtomicInteger: 原子更新整型。 AtomicLong: 原子更新长整型。 以上3个类提供的方法几乎一模一样，以AtomicInteger为例进行详解，AtomicIngeter的常用方...
Java中的原子类
weixin_39477597的博客
11-06 1343
一、什么是原子类 一个操作是不可中断的，即使是多线程的情况下也可以保证 在java中原子类都被保存在 java.util.concurrent.atomatic 二、原子类的作用 原子类的作用和锁类似，是为了保证并发情况下线程安全，不过原子类相比于锁，有一定的优势。 粒度更细，原子变量可以把竞争范围缩小到变量级别，这是我们可以获得的最细粒度的情况了，通常锁的粒度都要大于原子变量的粒度。 效率更高，通常使用原子类的效率比使用锁的效率更高，除了高度竞争的情况。 三、原子类纵览 Atomic*
深入理解Java并发之synchronized实现原理
热门推荐
zejian的博客
06-04 40万+
【版权申明】未经博主同意，谢绝转载！（请尊重原创，博主保留追究权） http://blog.csdn.net/javazejian/article/details/72828483 出自【zejian的博客】 关联文章： 深入理解Java类型信息(Class对象)与反射机制 深入理解Java枚举类型(enum) 深入理解Java注解类型(@Annotation) 深...
java原子类详解
yetaoii的博客
07-21 6682
java原子类详解 什么原子类 原子类是具有原子性的类，原子性的意思是对于一组操作，要么全部执行成功，要么全部执行失败，不能只有其中某几个执行成功。 原子类作用 作用和锁有类似之处，是为了保证并发情况下的线程安全。 相对于锁的优势 粒度更细 原子变量可以把竞争范围缩小到变量级别,通常情况下锁的粒度也大于原子变量的粒度 效率更高 除了在高并发之外，使用原子类的效率往往比使用同步互斥锁的效率更高，因为原子类底层利用了CAS，不会阻塞线程。 原子类种类 在JDK中J.U.C包下提供了种类丰富的原子类，
java lock 实现原理_Lock的实现原理
weixin_35824806的博客
02-13 1728
1. Lock 的简介及使用Lock是java 1.5中引入的线程同步工具，它主要用于多线程下共享资源的控制。本质上Lock仅仅是一个接口(位于源码包中的java\util\concurrent\locks中)，它包含以下方法//尝试获取锁，获取成功则返回，否则阻塞当前线程voidlock();//尝试获取锁，线程在成功获取锁之前被中断，则放弃获取锁，抛出异常void lockInterrupti...
简单了解java volatile关键字实现的原理
08-25
Java中的`volatile`关键字是用来解决多线程环境下的可见性和有序性问题的，它确保了共享变量在被修改后，其他线程能够立即看到最新的值，但并不保证操作的原子性。下面我们将深入探讨`volatile`关键字的原理、使用...
Java concurrency之AtomicLong原子类_动力节点Java学院整理
08-30
Java concurrency之AtomicLong原子类 AtomicLong是Java concurrency中的一种原子类，用于对长整形进行原子操作。在32位操作系统中，64位的long和double变量由于会被JVM当作两个分离的32位来进行操作，所以不具有...
java 中volatile和lock原理分析
08-30
《Java中volatile与锁原理分析》 在多线程编程中，确保数据的一致性和可见性是至关重要的。Java提供了两种主要的机制来实现这一目标：volatile关键字和锁。本文将深入探讨这两种机制的原理，以及它们在实际编程中的...
Java CAS原理深度分析
07-12
Java中CAS的具体实现主要依赖于`java.util.concurrent.atomic`包下的原子类，如`AtomicInteger`等。以`AtomicInteger`为例，该类中的`incrementAndGet()`方法使用CAS来实现线程安全的自增操作： ```java public ...
Java CAS 原理分析
06-14
### Java CAS 原理分析 #### 一、概述 CAS（Compare and Swap）作为一种重要的同步机制，在多线程环境中发挥着关键作用。它能够帮助开发者实现无锁编程，提高程序运行效率。本文将深入剖析Java中CAS的基本原理及其...
12. Hibernate 模板设计模式
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1257
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
golang 接口
m0_70982551的博客
07-24 803
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
最新发布
a1058926697的博客
07-26 363
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
springboot之自动装配
weixin_50153914的博客
07-23 485
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
淘客返利系统中的服务发现与注册机制详解
技术研究中心
07-22 2393
通过服务注册中心，服务提供者可以将自己注册到注册中心，服务消费者可以从注册中心获取服务提供者的地址，以实现服务调用。本文详细介绍了淘客返利系统中服务发现与注册机制的实现，包括Eureka的配置与代码示例。通过Eureka，我们可以轻松实现服务的注册与发现，确保分布式系统中各个服务之间的通信。在本文中，我们将深入探讨淘客返利系统中的服务发现与注册机制，并结合Java代码进行详细讲解。在我们的淘客返利系统中，我们采用Eureka作为服务发现与注册的工具。在我们的淘客返利系统中，首先需要配置Eureka服务器。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

大道之简

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值