JAVA并发编程（八）-无锁-乐观锁（非阻塞）

最新推荐文章于 2025-05-01 10:28:08 发布
最新推荐文章于 2025-05-01 10:28:08 发布
阅读量1k 收藏 25
点赞数 28
文章标签： java 开发语言 jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_36531037/article/details/136116946
版权

文章目录

🐶一、无锁实现（CAS）

1、代码演示

首先我们来看一下这段代码

public class TestAccount {
    public static void main(String[] args) {
        Account account = new AccountCas(10000);
        Account.demo(account);
    }
}

class AccountCas implements Account {
    private Integer balance;

    public AccountCas(int balance) {
        this.balance = balance;
    }

    @Override
    public Integer getBalance() {
        return balance;
    }

    @Override
    public void withdraw(Integer amount) {
        /*while(true) {
            // 获取余额的最新值
            int prev = balance.get();
            // 要修改的余额
            int next = prev - amount;
            // 真正修改
            if(balance.compareAndSet(prev, next)) {
                break;
            }
        }*/
        this.balance -= amount;
    }


}

class AccountUnsafe implements Account {

    private Integer balance;

    public AccountUnsafe(Integer balance) {
        this.balance = balance;
    }

    @Override
    public Integer getBalance() {
        synchronized (this) {
            return this.balance;
        }
    }

    @Override
    public void withdraw(Integer amount) {
        synchronized (this) {
            this.balance -= amount;
        }
    }
}

interface Account {
    // 获取余额
    Integer getBalance();

    // 取款
    void withdraw(Integer amount);

    /**
     * 方法内会启动 1000 个线程，每个线程做 -10 元 的操作
     * 如果初始余额为 10000 那么正确的结果应当是 0
     */
    static void demo(Account account) {
        List<Thread> ts = new ArrayList<>();
        for (int i = 0; i < 1000; i++) {
            ts.add(new Thread(() -> {
                account.withdraw(10);
            }));
        }
        long start = System.nanoTime();
        ts.forEach(Thread::start);
        ts.forEach(t -> {
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        long end = System.nanoTime();
        System.out.println(account.getBalance()
                + " cost: " + (end - start) / 1000_000 + " ms");
    }
}

结果显示：
在这里插入图片描述

  这里我们启用了1000个线程对Integer类型的balance变量进行修改，我们可以看到这里预计的结果应该为0，而这里显示了500，很明显这里是线程不安全的，有可能会出现指令交错的情况，所以才会导致理想的结果不正确。

   @Override
    public synchronized void withdraw(Integer amount) {
        /*while(true) {
            // 获取余额的最新值
            int prev = balance.get();
            // 要修改的余额
            int next = prev - amount;
            // 真正修改
            if(balance.compareAndSet(prev, next)) {
                break;
            }
        }*/
        this.balance -= amount;
    }

我们可以对这个进行修改的操作加上锁再来看看结果。
在这里插入图片描述
这里调用withDraw方法的时候都会去加上锁，流程是没有任何的问题，但这里会引申出一个问题，每一次频繁地加锁解锁会影响计算机的性能，所以我们这里引申出一种JDK提供给我们的原子类进行优化。AtomicInteger。

public class TestAccount {
    public static void main(String[] args) {
        Account account = new AccountCas(10000);
        Account.demo(account);
    }
}

class AccountCas implements Account {
    private AtomicInteger balance;

    public AccountCas(int balance) {
        this.balance = new AtomicInteger(balance);
    }

    @Override
    public Integer getBalance() {
        return balance.get();
    }

   @Override
    public void withdraw(Integer amount) {
        while(true) {
            // 获取余额的最新值
            int prev = balance.get();
            // 要修改的余额
            int next = prev - amount;
            // 真正修改
            if(balance.compareAndSet(prev, next)) {
                break;
            }
        }
        //balance.getAndAdd(-1 * amount);
    }
}

class AccountUnsafe implements Account {

    private Integer balance;

    public AccountUnsafe(Integer balance) {
        this.balance = balance;
    }

    @Override
    public Integer getBalance() {
        synchronized (this) {
            return this.balance;
        }
    }

    @Override
    public void withdraw(Integer amount) {
        synchronized (this) {
            this.balance -= amount;
        }
    }
}

interface Account {
    // 获取余额
    Integer getBalance();

    // 取款
    void withdraw(Integer amount);

    /**
     * 方法内会启动 1000 个线程，每个线程做 -10 元 的操作
     * 如果初始余额为 10000 那么正确的结果应当是 0
     */
    static void demo(Account account) {
        List<Thread> ts = new ArrayList<>();
        for (int i = 0; i < 1000; i++) {
            ts.add(new Thread(() -> {
                account.withdraw(10);
            }));
        }
        long start = System.nanoTime();
        ts.forEach(Thread::start);
        ts.forEach(t -> {
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        long end = System.nanoTime();
        System.out.println(account.getBalance()
                + " cost: " + (end-start)/1000_000 + " ms");
    }
}

执行结果：
在这里插入图片描述
我们可以看到这里用AtomicInteger解决了线程安全的问题。
接下来我们来看一下这里的compareAndSet（CAS）是如何进行工作的。
在这里插入图片描述
总结：这里每一次去更新的时候，都会先去检查当前的变量是否已经被改动了，如果被改动了，则不会再去进行更新，顾名思义CAS。

2、CAS效率分析

在这里插入图片描述
在这里插入图片描述

3、CAS的特点

在这里插入图片描述

🐱二、原子整数

在这里插入图片描述
通过上面的介绍，我们就可以改进一下之前的这段代码

@Override
    public void withdraw(Integer amount) {
//        while(true) {
//            // 获取余额的最新值
//            int prev = balance.get();
//            // 要修改的余额
//            int next = prev - amount;
//            // 真正修改
//            if(balance.compareAndSet(prev, next)) {
//                break;
//            }
//        }
        balance.getAndAdd(-1 * amount);
    }

🐭三、原子引用

为什么需要原子引用类型？
需要保护的共享数据不一定都是基本类型，我们也需要保护对象中的其他类型

1、代码演示

@Slf4j(topic = "c.Test35")
public class Test35 {
    public static void main(String[] args) {
        DecimalAccount.demo(new DecimalAccountCas(new BigDecimal("10000")));
    }
}

class DecimalAccountCas implements DecimalAccount {
    private AtomicReference<BigDecimal> balance;

    public DecimalAccountCas(BigDecimal balance) {
//        this.balance = balance;
        this.balance = new AtomicReference<>(balance);
    }

    @Override
    public BigDecimal getBalance() {
        return balance.get();
    }

    @Override
    public void withdraw(BigDecimal amount) {
        while(true) {
            BigDecimal prev = balance.get();
            BigDecimal next = prev.subtract(amount);
            if (balance.compareAndSet(prev, next)) {
                break;
            }
        }
    }
}

interface DecimalAccount {
    // 获取余额
    BigDecimal getBalance();

    // 取款
    void withdraw(BigDecimal amount);

    /**
     * 方法内会启动 1000 个线程，每个线程做 -10 元 的操作
     * 如果初始余额为 10000 那么正确的结果应当是 0
     */
    static void demo(DecimalAccount account) {
        List<Thread> ts = new ArrayList<>();
        for (int i = 0; i < 1000; i++) {
            ts.add(new Thread(() -> {
                account.withdraw(BigDecimal.TEN);
            }));
        }
        ts.forEach(Thread::start);
        ts.forEach(t -> {
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        System.out.println(account.getBalance());
    }
}

结果展示：
在这里插入图片描述
这里我们可以看到我们保护的BigDecimal是线程安全的。

2、ABA问题

在这里插入图片描述

这里我们可以看到当变量中途被修改过以后，最终主线程还是会把A->C，这就是ABA问题，对于主线程来说察觉不到ref变量曾经被修改过，如果我们收到这样的一个需求，当ref被改动过了以后，主线程就不会再去改动ref了，那么我们应该如何去实现呢？
接下来我们来看一下如何进行改进。

@Slf4j(topic = "c.Test36")
public class Test36 {

    static AtomicStampedReference<String> ref = new AtomicStampedReference<>("A", 0);

    public static void main(String[] args) throws InterruptedException {
        log.debug("main start...");
        // 获取值 A
        String prev = ref.getReference();
        // 获取版本号
        int stamp = ref.getStamp();
        log.debug("版本 {}", stamp);
        // 如果中间有其它线程干扰，发生了 ABA 现象
        other();
        TimeUnit.SECONDS.sleep(1);
        // 尝试改为 C
        log.debug("change A->C {}", ref.compareAndSet(prev, "C", stamp, stamp + 1));
    }

    private static void other() throws InterruptedException {
        new Thread(() -> {
            log.debug("change A->B {}", ref.compareAndSet(ref.getReference(), "B", ref.getStamp(), ref.getStamp() + 1));
            log.debug("更新版本为 {}", ref.getStamp());
        }, "t1").start();
        TimeUnit.MILLISECONDS.sleep((int) (0.5 * 1000));
        new Thread(() -> {
            log.debug("change B->A {}", ref.compareAndSet(ref.getReference(), "A", ref.getStamp(), ref.getStamp() + 1));
            log.debug("更新版本为 {}", ref.getStamp());
        }, "t2").start();
    }
}

执行结果：
在这里插入图片描述

3、AtomicMarkableReference

在这里插入图片描述

代码演示：

@Slf4j(topic = "c.Test38")
public class Test38 {
    public static void main(String[] args) throws InterruptedException {
        GarbageBag bag = new GarbageBag("装满了垃圾");
        // 参数2 mark 可以看作一个标记，表示垃圾袋满了
        AtomicMarkableReference<GarbageBag> ref = new AtomicMarkableReference<>(bag, true);

        log.debug("start...");
        GarbageBag prev = ref.getReference();
        log.debug(prev.toString());

        new Thread(() -> {
            log.debug("start...");
            bag.setDesc("空垃圾袋");
            ref.compareAndSet(bag, bag, true, false);
            log.debug(bag.toString());
        },"保洁阿姨").start();

        TimeUnit.SECONDS.sleep(1);
        log.debug("想换一只新垃圾袋？");
        boolean success = ref.compareAndSet(prev, new GarbageBag("空垃圾袋"), true, false);
        log.debug("换了么？" + success);
        log.debug(ref.getReference().toString());
    }
}

class GarbageBag {
    String desc;

    public GarbageBag(String desc) {
        this.desc = desc;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }

    @Override
    public String toString() {
        return super.toString() + " " + desc;
    }
}

结果演示：
在这里插入图片描述

🐹四、原子数组

代码演示：

public class Test39 {

    public static void main(String[] args) {
        demo(
                ()->new int[10],
                (array)->array.length,
                (array, index) -> array[index]++,
                array-> System.out.println(Arrays.toString(array))
        );

        demo(
                ()-> new AtomicIntegerArray(10),
                (array) -> array.length(),
                (array, index) -> array.getAndIncrement(index),
                array -> System.out.println(array)
        );
    }

    /**
     参数1，提供数组、可以是线程不安全数组或线程安全数组
     参数2，获取数组长度的方法
     参数3，自增方法，回传 array, index
     参数4，打印数组的方法
     */
    // supplier 提供者 无中生有  ()->结果
    // function 函数   一个参数一个结果   (参数)->结果  ,  BiFunction (参数1,参数2)->结果
    // consumer 消费者 一个参数没结果  (参数)->void,      BiConsumer (参数1,参数2)->
    private static <T> void demo(
            Supplier<T> arraySupplier,
            Function<T, Integer> lengthFun,
            BiConsumer<T, Integer> putConsumer,
            Consumer<T> printConsumer ) {
        List<Thread> ts = new ArrayList<>();
        T array = arraySupplier.get();
        int length = lengthFun.apply(array);
        for (int i = 0; i < length; i++) {
            // 每个线程对数组作 10000 次操作
            ts.add(new Thread(() -> {
                for (int j = 0; j < 10000; j++) {
                    putConsumer.accept(array, j%length);
                }
            }));
        }

        ts.forEach(t -> t.start()); // 启动所有线程
        ts.forEach(t -> {
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });     // 等所有线程结束
        printConsumer.accept(array);
    }
}

执行结果：
在这里插入图片描述
我们可以看到这里对数组内部的元素进行操作的时候，数组每一个坐标下都分别新建10000条线程进行+1操作，这里可以看到AtomicIntegerArray是线程安全的。

🐰五、字段更新器

字段更新器保护的是某个对象里的属性成员变量，能保证多个线程在访问同一个对象的成员变量时的安全性。
在这里插入图片描述
代码演示：

@Slf4j(topic = "c.Test40")
public class Test40 {

    public static void main(String[] args) {
        Student stu = new Student();

        AtomicReferenceFieldUpdater updater =
                AtomicReferenceFieldUpdater.newUpdater(Student.class, String.class, "name");

        System.out.println(updater.compareAndSet(stu, null, "张三"));
        System.out.println(stu);
    }
}

class Student {
    volatile String name;

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                '}';
    }
}

在这里插入图片描述

🦊六、原子累加器

在JDK8以后专门增加了几个用来做累加的类，LongAdder，他们的性能要比AtomicInteger要高得多。

我们先来比较一下AtomicLong和LongAdder的性能。

代码演示：

public class Test41 {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            demo(
                    () -> new AtomicLong(0),
                    (adder) -> adder.getAndIncrement()
            );
        }

        for (int i = 0; i < 5; i++) {
            demo(
                    () -> new LongAdder(),
                    adder -> adder.increment()
            );
        }
    }

    /*
    () -> 结果    提供累加器对象
    (参数) ->     执行累加操作
     */
    private static <T> void demo(Supplier<T> adderSupplier, Consumer<T> action) {
        T adder = adderSupplier.get();
        List<Thread> ts = new ArrayList<>();
        // 4 个线程，每人累加 50 万
        for (int i = 0; i < 4; i++) {
            ts.add(new Thread(() -> {
                for (int j = 0; j < 500000; j++) {
                    action.accept(adder);
                }
            }));
        }
        long start = System.nanoTime();
        ts.forEach(t -> t.start());
        ts.forEach(t -> {
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        long end = System.nanoTime();
        System.out.println(adder + " cost:" + (end - start) / 1000_000);
    }
}

结果展示：
在这里插入图片描述
我们这里可以看到LongAdder的性能明显要比AtomicLong高。

为什么LongAdder的性能会比AtomicLong高呢？
在这里插入图片描述
相比于AtomicLong，LongAdder会根据CPU线程数的数量，去新建累加单元，先在每个累加单元下进行计算，计算完成后，最后把每个累加单元的数进行求和，这样子就能够计算出最后的结果了。

关于原子累加器LongAdder的源码分析可以再去参考黑马课程中JAVA并发编程的讲解。这里就不再进行叙述了。

🐻七、Unsafe

概述：
Unsafe对象提供了非常底层的，操作内存、线程的方法，Unsafe对象不能直接调用，只能够通过反射获得。

演示代码：

public class TestUnsafe {

    public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {
        Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");
        theUnsafe.setAccessible(true);
        Unsafe unsafe = (Unsafe) theUnsafe.get(null);

        System.out.println(unsafe);

        // 1. 获取域的偏移地址
        long idOffset = unsafe.objectFieldOffset(Teacher.class.getDeclaredField("id"));
        long nameOffset = unsafe.objectFieldOffset(Teacher.class.getDeclaredField("name"));

        Teacher t = new Teacher();
        // 2. 执行 cas 操作
        unsafe.compareAndSwapInt(t, idOffset, 0, 1);
        unsafe.compareAndSwapObject(t, nameOffset, null, "张三");

        // 3. 验证
        System.out.println(t);
    }
}
@Data
class Teacher {
    volatile int id;
    volatile String name;
}

执行结果：
在这里插入图片描述

imperfectsam
关注
无锁并发编程：Java原子操作类及CAS机制全面剖析
逆流的小鱼
05-03 1069
AtomicBoolean 用于布尔值的原子操作。AtomicInteger 和 AtomicLong 分别用于整型和长整型数值的原子操作。这些类内部主要利用了 volatile 变量和 CAS 操作来实现线程安全的更新操作。volatile 关键字保证了变量的可见性，而 CAS 保证了更新操作的原子性。AtomicReference 类可用于存储和操作对象引用，保证了引用操作的原子性。我们可以使用此类在多线程环境下安全地读取、写入和更新共享对象。} }} }
锁的艺术：Java并发中的常用锁策略与实践
热门推荐
张彦峰的博客
05-12 169万+
对java锁相关内容进行整理分析：乐观锁 VS 悲观锁+自旋锁 VS 适应性自旋锁+无锁 VS 偏向锁 VS 轻量级锁 VS 重量级锁+公平锁 VS 非公平锁+可重入锁 VS 非可重入锁+独享锁 VS 共享锁
学习笔记：Java 并发编程④_无锁
做笔记，记录学习中遇到的问题。
01-27 1327
本章内容：CAS 与 volatile；CAS 的相关 API：原子整数、原子引用、原子累加器；Unsafe。
CAS无锁编程的底层秘密：从CPU指令到Java原子类，一文穿透实现原理
最新发布
欢迎来到码农技术栈！在这里，我们专注于科技互联网领域的深度剖析和技术栈的全面解析。我们分享最新的行业动态、技术趋势、项目实战经验和深度技术文章，帮助您紧跟技术前沿，提升专业技能！
05-01 910
CAS的核心是“乐观并发控制”：相信冲突很少，通过硬件原子指令和用户态重试，在无锁的情况下实现线程安全。它是Java并发包（）的基石，支撑了原子类、并发集合等高性能组件。记住CAS适合低冲突、单个变量、读多写少的场景；高冲突时，CAS的循环重试反而比锁更慢；遇到ABA问题，记得用带版本号的原子类（理解CAS的底层原理，就能在多线程编程中灵活选择“锁”与“无锁”，写出高性能的并发代码～ 💥下期聊聊“Java内存模型JMM：从可见性到有序性，彻底搞懂多线程数据不一致问题”～
Java的无锁编程和锁优化
四火专栏
08-07 231
在这篇文章里面已经提到了三件事情：1、Peterson 算法，2、ConcurrentHashMap，3、无锁编程的初识。   如果站在语言层面之上，仅从设计的层面看，可以避免锁的思路至少包括： 1、单线程来主导行为，多线程池化操作避开状态变量。 比如在一个WEB应用中，每一个Action都可以给相应的用户线程分配一个实例，线程之间互不干扰；但是到了业务逻辑Service内，避开Servi...
cas无法使用_使用CAS、FAA实现无锁编程
weixin_39603823的博客
11-28 228
锁会导致性能降低，在特定情况可用硬件同步原语替代锁，保证和锁一样数据安全，同时提供更好性能。硬件同步原语(Atomic Hardware Primitives)由计算机硬件提供的一组原子操作，较常用的原语主要是CAS和FAA两种。CAS(Compare and Swap)比较交换FAA原语(Fetch and Add)语义是，先获取变量p当前的值value，然后给变量p增加inc，最后返...
Java无锁并发
weixin_43374578的博客
11-20 803
...
Java 多线程与并发(3-26)-Java 并发 - Java中所有的锁.pdf
07-20
Java并发编程中，锁是一种关键机制，用于控制多个线程对共享资源的访问。本文主要探讨了Java中的两种广义锁概念——乐观锁和悲观锁，以及自旋锁和适应性自旋锁的区别和应用场景。 1. 乐观锁与悲观锁： 乐观锁认为在...
Java并发编程之原子变量与非阻塞同步机制
09-03
Java并发编程是多线程环境下确保程序正确执行的关键技术，其中原子变量和非阻塞同步机制扮演着重要角色。非阻塞算法不同于传统的基于锁的同步机制，它们允许线程在不阻塞其他线程的情况下进行操作，提高了系统的并发...
超越并发瓶颈：CAS与乐观锁的智慧应用
张彦峰的博客
04-25 5万+
synchronized 是 Java 内置的同步机制，依赖 JVM 实现，通过进入和退出监视器锁（Monitor Lock）来保证线程的安全性。在高并发情况下，线程可能会频繁地在 BLOCKED 状态和 RUNNABLE 状态之间切换，导致用户态和内核态的频繁切换，从而影响性能。 CAS和乐观锁作为两种重要的并发控制机制备受关注。CAS机制直接利用硬件保证原子性，而乐观锁则基于乐观的思想进行并发控制。本文将学习这两种机制的原理、应用及性能特点来进行体会
Java 并发编程
weixin_46531416的博客
08-06 1090
Java 并发编程详解
Java 并发编程_无锁并发
weixin_48922154的博客
04-10 1717
文章目录1. 无锁解决线程安全问题2. CAS与volatile3. 原子整数4. 原子引用4.1 ABA问题4.2 AtomicStampedReference4.3 AtomicMarkableReference 1. 无锁解决线程安全问题 举例： package top.nnzi.concurrent.chapter02; import java.util.ArrayList; import java.util.List; import java.util.concurrent.atomic.Ato
java无锁_Java无锁并发
weixin_42437984的博客
02-12 316
1. 问题提出有如下需求，保证 account.withdraw 取款方法的线程安全package cn.itcast;import java.util.ArrayList;import java.util.List;interface Account {// 获取余额 Integer getBalance();// 取款 void withdraw(Integer amount);/...
[高并发Java 四] 无锁
LSDNH_123的博客
09-08 681
摘要 本系列基于炼数成金课程，为了更好的学习，做了系列的记录。 本文主要介绍: 1.无锁类的原理详解 2.无锁类的使用 在[高并发Java 一] 前言中已经提到了无锁的概念，由于在jdk源码中有大量的无锁应用，所以在这里介绍下无锁。 1 无锁类的原理详解 1.1 CAS CAS算法的过程是这样：它包含3个参数CAS(V,E,N)。V表示要更新的变量，E表示预期值，N表
Java并发练习：无锁编程
萌白在努力的博客
04-17 268
目标：利用AtomicStampedReference实现栈的压入弹出无锁编程 AtomicStampedReference 意义：对数据进行CAS（compareAndSet）无锁自加或者更换栈的表头之类的问题时会出现ABA问题，AtomicStampedReference通过增加版本号（时间戳）来解决这个问题。 AtomicStampedReference(V initialRef, int initialStamp)：初始化，传入初始数据与初始版本号 getReference()：获取当前引用数据
java非阻塞锁_Java多线程程序非阻塞式锁定实现
weixin_39638105的博客
02-16 377
对多线程程序的锁定已经有良好的支持，通常使用synchronized修饰一个方法或者一段代码。但是有一个问题，多个线程同时调用同一个方法的时候，所有线程都被排队处理了。该被调用的方法越耗时，线程越多的时候，等待的线程等待的时间也就越长，甚至于几分钟或者几十分钟。对于Web等对反应时间要求很高的系统来说，这是不可以接受的。本文就介绍一种自己实现的锁定方法，可以在没有拿到锁之后马上返回，告诉客户稍候重...
java非阻塞锁_Java并发问题的非阻塞解决方案
weixin_39588983的博客
02-16 1055
转自http://blog.youkuaiyun.com/u011277203/article/details/9223545在并发环境中，对于共享资源通常会采用显式的锁机制(比如synchronized或ReentrantLock)来保证在任意时刻只会有一条线程访问这些变量，并且这些变量的修改对随后获取锁的线程是可见的。无法获取锁的线程会进入阻塞状态，并被JVM和操作系统挂起，在未来某一时刻被调度重新获取锁...
JAVA高并发四 无锁
菜园子丶For丨丶Tomorrow的博客
08-13 722
CAS无锁实现原理 为什么要用CAS         在多线程高并发编程的时候，最关键的问题就是保证临界区的对象的安全访问。通常是用加锁来处理，其实加锁本质上是将并发转变为串行来实现的，势必会影响吞吐量。而且线程的数量是有限的，依赖于操作系统，而且线程的创建和销毁带来的性能损耗是不可以忽略掉的。虽然现在基本都是用线程池来尽可能的降低不断创建线程带来的性能损耗。         对于并发控制而...
Java中的无锁编程
weixin_34292402的博客
08-09 1165
2019独角兽企业重金招聘Python工程师标准>>> ...
Java并发编程：CAS、乐观锁与悲观锁解析
CAS广泛应用于java.util.concurrent.atomic包中的原子类，如AtomicInteger和AtomicLong，用于实现非阻塞的数据结构。 2. **乐观锁与悲观锁**：乐观锁假设并发环境中很少发生冲突，所以在进行操作时不加锁，只有在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值