CAS与volatile、原子整数、原子引用、原子数组、字段更新器、原子累加器、Unsafe

最新推荐文章于 2023-02-07 21:27:35 发布

Zhang_960110

最新推荐文章于 2023-02-07 21:27:35 发布

阅读量652

点赞数 2

分类专栏： Java并发编程文章标签： java

本文链接：https://blog.csdn.net/ZSA222/article/details/123471728

版权

Java并发编程专栏收录该内容

15 篇文章 10 订阅

订阅专栏

文章目录

1.问题引出
- 1.1 保护共享资源-加锁实现
- 1.2 保护共享资源-无锁实现
2.CAS与volatile
3.原子整数
4.原子引用
5.原子数组
6.字段更新器
7.原子累加器
8.Unsafe

1.问题引出

1.1 保护共享资源-加锁实现

使用synchronized来保证多线程访问共享资源发生的安全问题

/**
 * Description: 保护共享资源-加锁实现 和 无锁实现
 */
@Slf4j
public class Test1 {

    public static void main(String[] args) {

        Account.demo(new AccountSynchronized(10000));

    }
}

/**
 * 保护共享资源-加锁实现
 */
class AccountSynchronized implements Account {

    private Integer balance;

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

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

    @Override
    public void withdraw(Integer amount) {
        synchronized (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<>();

        // 1000 个线程
        for (int i = 0; i < 1000; i++) {
            ts.add(new Thread(() -> {
                account.withdraw(10);
            }));
        }

        long start = System.nanoTime();

        // 启动
        ts.forEach(Thread::start);

        // join 等待线程执行完毕
        ts.forEach(t -> {
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        long end = System.nanoTime();

        // 打印余额 及消耗时间
        System.out.println(account.getBalance()
                + " cost: " + (end - start) / 1000000 + " ms");
    }
}

运行结果

0 cost: 41 ms

Process finished with exit code 0

1.2 保护共享资源-无锁实现

/**
 * Description: 保护共享资源-加锁实现 和 无锁实现
 */
@Slf4j
public class Test1 {

    public static void main(String[] args) {

        // Account.demo(new AccountSynchronized(10000));

        Account.demo(new AccountCas(10000));

    }
}

/**
 * 保护共享资源-无锁实现
 */
class AccountCas implements Account {

    // 原子整数
    private AtomicInteger balance;

    public AccountCas(Integer 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;
            // 真正修改-同步到主存中 修改成功返回 true
            boolean b = balance.compareAndSet(prev, next);
            if (b) {
                break;
            }
        }
    }
}


/**
 * 保护共享资源-加锁实现
 */
class AccountSynchronized implements Account {

    private Integer balance;

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

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

    @Override
    public void withdraw(Integer amount) {
        // 通过这里加锁就可以实现线程安全，不加就会导致线程安全问题
        synchronized (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<>();

        // 1000 个线程
        for (int i = 0; i < 1000; i++) {
            ts.add(new Thread(() -> {
                account.withdraw(10);
            }));
        }

        long start = System.nanoTime();

        // 启动
        ts.forEach(Thread::start);

        // join 等待线程执行完毕
        ts.forEach(t -> {
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        long end = System.nanoTime();

        // 打印余额 及消耗时间
        System.out.println(account.getBalance()
                + " cost: " + (end - start) / 1000000 + " ms");
    }
}

运行结果

0 cost: 27 ms

Process finished with exit code 0

2.CAS与volatile

2.1 CAS工作流程

前面看到的AtomicInteger的解决方法，内部并没有用锁来保护共享变量的线程安全。那么它是如何实现的呢？


	private AtomicInteger balance;

	@Override
    public void withdraw(Integer amount) {
        while (true) {
            // 获取余额最新值
            int prev = balance.get();
            // 修改后的余额
            int next = prev - amount;
            // 真正修改-同步到主存中 修改成功返回 true
            /*
             compareAndSet 比较并设置:
             ① 线程A首先获取balance.get(),拿到当前的balance值prev
             ② 根据这个prev值 - amount值 = 修改后的值next
             ③ 调用compareAndSet方法, 首先会判断当初拿到的prev值,是否和现在的
                balance值相同;
                3.1、如果相同,表示其他线程没有修改balance的值, 此时就可以将next值
                    设置给balance属性
                3.2、如果不相同,表示其他线程也修改了balance值, 此时就设置next值失败,
                    然后一直重试, 重新获取balance.get()的值,计算出next值,
                    并判断本次的prev和balance的值是否相同...重复上面操作
		    */
            boolean b = balance.compareAndSet(prev, next);
            if (b) {
                break;
            }
        }
    }

其中的关键是 compareAndSet, 它的简称就是CAS(也有 Compare And Swap的说法),它必须是原子操作。
在这里插入图片描述

2.2 volatile作用

获取共享变量时，为了保证该变量的可见性，需要使用volatile 修饰。
它可以用来修饰成员变量和静态成员变量，他可以避免线程从自己的工作缓存中查找变量的值，必须到主存中获取它的值，线程操作 volatile 变量都是直接操作主存。即一个线程对 volatile 变量的修改，对另一个线程可见。
volatile仅仅保证了共享变量的可见性，让其它线程能够看到最新值，但不能解决指令交错问题(不能保证原子性)
CAS必须借助 volatile 才能读取到共享变量的最新值来实现【比较并交换】的效果

在这里插入图片描述

2.3 CAS效率分析

无锁情况下，即使重试失败，线程始终在高速运行，没有停歇，而 synchronized 会让线程在没有获得锁的时候，发生上下文切换，进入阻塞。打个比喻
线程就好像高速跑道上的赛车，高速运行时，速度超快，一旦发生上下文切换，就好比赛车要减速、熄火，等被唤醒又得重新打火、启动、加速。。恢复到高速运行，代价比较大。
但无锁情况下，因为线程要保持运行，需要额外 CPU的支持，CPU在这里就好比高速跑道。但是没有额外的跑道，线程想高速运行也无从谈起，虽然不会进入阻塞，但由于没有分到时间片，仍然会进入可运行状态，还是会导致上下文切换。

2.4 CAS特点

结合CAS和 volatile可以实现无锁并发，适用于线程数少、多核CPU的场景下。
CAS 是基于乐观锁的思想：最乐观的估计，不怕别的线程来修改共享变量，就算改了也没关系，我吃亏点再重试呗。
synchronized 是基于悲观锁的思想：最悲观的估计，得防着其它线程来修改共享变量，我上了锁你们都别想改，我改完了解开锁，你们才有机会。
CAS 体现的是无锁并发、无阻塞并发，请仔细体会这两句话的意思
因为没有使用 synchronized，所以线程不会陷入阻塞，这是效率提升的因素之一
但如果竞争激烈，可以想到重试必然频繁发生，反而效率会受影响

3.原子整数

JUC并发包提供了：

AtomicBoolean
AtomicInteger
AtomicLong

以 AtomicInteger为例

public class AtomicIntegerTest {
    public static void main(String[] args) {
        AtomicInteger i = new AtomicInteger(0);

        // 获取并自增（i = 0, 结果 i = 1, 返回 0），类似于 i++
        System.out.println(i.getAndIncrement());

        // 自增并获取（i = 1, 结果 i = 2, 返回 2），类似于 ++i
        System.out.println(i.incrementAndGet());

        // 自减并获取（i = 2, 结果 i = 1, 返回 1），类似于 --i
        System.out.println(i.decrementAndGet());

        // 获取并自减（i = 1, 结果 i = 0, 返回 1），类似于 i--
        System.out.println(i.getAndDecrement());

        // 获取并加值（i = 0, 结果 i = 5, 返回 0）
        System.out.println(i.getAndAdd(5));

        // 加值并获取（i = 5, 结果 i = 0, 返回 0）
        System.out.println(i.addAndGet(-5));

        // 获取并更新（i = 0, p 为 i 的当前值, 结果 i = -2, 返回 0）
        // 函数式编程接口，其中函数中的操作能保证原子，但函数需要无副作用
        System.out.println(i.getAndUpdate(p -> p - 2));

        // 更新并获取（i = -2, p 为 i 的当前值, 结果 i = 0, 返回 0）
        // 函数式编程接口，其中函数中的操作能保证原子，但函数需要无副作用
        System.out.println(i.updateAndGet(p -> p + 2));

        // 获取并计算（i = 0, p 为 i 的当前值, x 为参数1, 结果 i = 10, 返回 0）
        // 函数式编程接口，其中函数中的操作能保证原子，但函数需要无副作用
        // getAndUpdate 如果在 lambda 中引用了外部的局部变量，要保证该局部变量是 final 的
        // getAndAccumulate 可以通过 参数1 来引用外部的局部变量，但因为其不在 lambda 中因此不必是 final
        System.out.println(i.getAndAccumulate(10, (p, x) -> p + x));

        // 计算并获取（i = 10, p 为 i 的当前值, x 为参数1值, 结果 i = 0, 返回 0）
        // 函数式编程接口，其中函数中的操作能保证原子，但函数需要无副作用
        System.out.println(i.accumulateAndGet(-10, (p, x) -> p + x));
    }

}

模拟updateAndGet的实现

public class UpdateAndGetTest {
    public static void main(String[] args) {

        AtomicInteger i = new AtomicInteger(5);

        int result = updateAndGet(i, x -> x * 10);

        System.out.println(result);


    }

    public static int updateAndGet(AtomicInteger i, IntUnaryOperator operator) {
        while (true) {
            int prev = i.get();
            int next = operator.applyAsInt(prev);
            if (i.compareAndSet(prev, next)) {
                return next;
            }
        }
    }

}

updateAndGet源码

public final int updateAndGet(IntUnaryOperator updateFunction) {
        int prev, next;
        do {
            prev = get();
            next = updateFunction.applyAsInt(prev);
        } while (!compareAndSet(prev, next));
        return next;
    }

4.原子引用

AtomicReference
AtomicMarkableReference
AtomicStampedReference

4.1 AtomicReference

AtomicReference和AtomicInteger非常类似，不同之处就在于AtomicInteger是对整数的封装，底层采用的是compareAndSwapInt实现CAS，比较的是数值是否相等，而AtomicReference则对应普通的对象引用，底层使用的是compareAndSwapObject实现CAS，比较的是两个对象的地址是否相等。也就是它可以保证你在修改对象引用时的线程安全性。

/**
 * 原子引用
 */
public class AtomicReferenceTest {
    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 = 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);

    static void demo(DecimalAccountCas account) {
        List<Thread> ts = new ArrayList<>();
        for (int i = 0; i < 1000; i++) {
            ts.add(new Thread(() -> {
                account.withdraw(new BigDecimal(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) / 1000000 + " ms");
    }
}

4.2 原子引用-ABA问题

CAS操作可能带来ABA问题，因为CAS操作需要在操作值的时候，检查值有没有发生变化，如果没有发发生变化则更新。如果一个值原来是A，变成了B，又变成了A，那么使用CAS进行检查时会认为它的值没有变化，但是实际上却变了。

@Slf4j
public class TestABA {

    static AtomicReference<String> ref = new AtomicReference<>("A");

    public static void main(String[] args) throws InterruptedException {

        log.debug("main start...");
        String prev = ref.get();

        other();

        Thread.sleep(1000);
        log.debug("change A->B " + ref.compareAndSet(prev, "B"));

    }

    static void other() throws InterruptedException {
        new Thread(() -> {
            // 此时ref.get()为A,此时共享变量ref也是A,没有被改过, 此时CAS
            // 可以修改成功, B
            log.debug("change A->B " + ref.compareAndSet(ref.get(), "B"));
        }).start();

        Thread.sleep(500);

        new Thread(() -> {
            // 同上, 修改为A
            log.debug("change B->A " + ref.compareAndSet(ref.get(), "A"));
        }).start();
    }

}

2022-03-14 15:38:00 [main] - main start...
2022-03-14 15:38:00 [Thread-0] - change A->B true
2022-03-14 15:38:00 [Thread-1] - change B->A true
2022-03-14 15:38:01 [main] - change A->B true

Process finished with exit code 0

主线程仅能判断出共享变量的值与最初值 A是否相同，不能感知到这种从 A 改为 B 又改回 A 的情况。
如果主线程希望：只要有其它线程【动过】共享变量，那么自己的 cas 就算失败，这时，仅比较值是不够的，需要再加一个版本号。使用AtomicStampedReference来解决。

4.3 AtomicStampedReference

@Slf4j
public class AtomicStampedReferenceTest {

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

    public static void main(String[] args) throws InterruptedException {

        log.debug("main start...");
        // 获取值
        String prev = ref.getReference();
        // 获取版本号
        int stamp = ref.getStamp();
        log.debug("{}",stamp);

        other();

        Thread.sleep(1000);
        log.debug("change A->B " + ref.compareAndSet(prev, "B",stamp,stamp + 1));

    }

    static void other() throws InterruptedException {
        new Thread(() -> {
            int stamp = ref.getStamp();
            log.debug("{}",stamp);
            log.debug("change A->B " + ref.compareAndSet(ref.getReference(), "B",stamp,stamp + 1));
        },"t1").start();

        Thread.sleep(500);

        new Thread(() -> {

            int stamp = ref.getStamp();
            log.debug("{}",stamp);
            log.debug("change B->A " + ref.compareAndSet(ref.getReference(), "A", stamp, stamp + 1));
        },"t2").start();
    }

}

4.4 AtomicMarkableReference

AtomicStampedReference可以给原子引用加上版本号，追踪原子引用整个的变化过程，如： A ->B->A->C，通过AtomicStampedReference，我们可以知道，引用变量中途被更改了几次。

但是有时候，并不关心引用变量更改了几次，只是单纯的关心是否更改过，所以就有了 AtomicMarkableReference

在这里插入图片描述

@Slf4j
public class AtomicMarkableReferenceTest {
    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("空垃圾袋");
            while (!ref.compareAndSet(bag, bag, true, false)) {
            }
            log.debug(bag.toString());
        }).start();
        
        Thread.sleep(1000);
        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;
    }
}

2022-03-14 17:28:33 [main] - 主线程 start...
2022-03-14 17:28:33 [main] - com.concurrent.cas.GarbageBag@b065c63 装满了垃圾
2022-03-14 17:28:33 [Thread-0] - 打扫卫生的线程 start...
2022-03-14 17:28:33 [Thread-0] - com.concurrent.cas.GarbageBag@b065c63 空垃圾袋
2022-03-14 17:28:34 [main] - 主线程想换一只新垃圾袋？
2022-03-14 17:28:34 [main] - 换了么？false
2022-03-14 17:28:34 [main] - com.concurrent.cas.GarbageBag@b065c63 空垃圾袋

Process finished with exit code 0

5.原子数组

使用原子的方式更新数组里的某个元素

AtomicIntegerArray：原子更新整型数组里的元素
AtomicLongArray：原子更新长整型数组里的元素。
AtomicReferenceArray：原子更新引用类型数组里的元素。

AtomicIntegerArray举例

public class AtomicArrayTest {
    public static void main(String[] args) {
        demo(
                () -> new int[10],
                array -> array.length,
                (array, index) -> array[index]++,
                array -> System.out.println(Arrays.toString(array))
        ); // [7467, 7354, 7364, 7310, 7288, 7298, 7282, 7310, 7659, 7621]

        demo(
                ()-> new AtomicIntegerArray(10),
                (array) -> array.length(),
                (array, index) -> array.getAndIncrement(index),
                array -> System.out.println(array)
        ); // [10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000]

        demo(
                ()-> new AtomicIntegerArray(10),
                AtomicIntegerArray::length,
                AtomicIntegerArray::getAndIncrement,
                System.out::println
        ); // [10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000]

    }

    /**
     * 参数1，提供数组、可以是线程不安全数组或线程安全数组
     * 参数2，获取数组长度的方法
     * 参数3，自增方法，回传 array, index
     * 参数4，打印数组的方法
     */
    // supplier 提供者 无中生有 ()->结果
    // function 函数 一个参数一个结果 (参数)->结果 , BiFunction (参数1,参数2)->结果
    // consumer 消费者 一个参数没结果 (参数)->void, BiConsumer (参数1,参数2)->void
    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++) {
            // 创建10个线程, 每个线程对数组作 10000 次操作
            ts.add(new Thread(() -> {
                for (int j = 0; j < 10000; j++) {
                    putConsumer.accept(array, j % length);
                }
            }));
        }

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

        printConsumer.accept(array);
    }
}

6.字段更新器

AtomicReferenceFieldUpdater // 域字段
AtomicIntegerFieldUpdater
AtomicLongFieldUpdater

利用字段更新器，可以针对对象的某个域 (Field)进行原子操作，只能配合 volatile 修饰的字段使用，否则会出现异常

Exception in thread "main" java.lang.IllegalArgumentException: Must be volatile type

@Slf4j
public class AtomicFieldTest {
    public static void main(String[] args) {
        Student stu = new Student();
        // 获得原子更新器
      	// 泛型
      	// 参数1 持有属性的类 参数2 被更新的属性的类
      	// newUpdater中的参数：第三个为属性的名称
        AtomicReferenceFieldUpdater<Student, String> updater = AtomicReferenceFieldUpdater.newUpdater(Student.class, String.class, "name");
        // 期望的为null, 如果name属性没有被别的线程更改过, 默认就为null, 此时匹配, 就可以设置name为张三
        System.out.println(updater.compareAndSet(stu, null, "张三"));
        System.out.println(updater.compareAndSet(stu, stu.name, "王五"));
        System.out.println(stu);
    }
}


class Student {

    volatile String name;

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                '}';
    }
}
```java
true
true
Student{name='王五'}

Process finished with exit code 0

7.原子累加器

累加器性能比较 AtomicLong, LongAddr

@Slf4j
public class Test {
    public static void main(String[] args) {
        System.out.println("----AtomicLong----");
        for (int i = 0; i < 5; i++) {
            demo(() -> new AtomicLong(0), adder -> adder.getAndIncrement());
        }

        System.out.println("----LongAdder----");
        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();
        long start = System.nanoTime();
        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);
                }
            }));
        }
        ts.forEach(Thread::start);
        ts.forEach(t -> {
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        long end = System.nanoTime();
        System.out.println(adder + " cost:" + (end - start) / 1000000);
    }
}

----AtomicLong----
2000000 cost:60
2000000 cost:67
2000000 cost:69
2000000 cost:51
2000000 cost:66
----LongAdder----
2000000 cost:7
2000000 cost:4
2000000 cost:3
2000000 cost:3
2000000 cost:3

Process finished with exit code 0

性能提升的原因很简单，就是在有竞争时，设置多个累加单元，Therad-0累加 CelI[0]，而 Thread-1累加 Cell[1]…最后将结果汇总。这样它们在累加时操作的不同的Cell 变量，因此减少了 CAS 重试失败，从而提高性能。

8.Unsafe

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

public class UnsafeTest {

    public static void main(String[] args) throws Exception {
        // 通过反射获得Unsafe对象
        Class<Unsafe> unsafeClass = Unsafe.class;
        // 获得构造函数，Unsafe的构造函数为私有的
        Constructor<Unsafe> constructor = unsafeClass.getDeclaredConstructor();
        // 设置为允许访问私有内容
        constructor.setAccessible(true);
        // 创建Unsafe对象
        Unsafe unsafe = constructor.newInstance();

        // 创建Person对象
        Person person = new Person();
        // 获得其属性 name 的偏移量
        long nameOffset = unsafe.objectFieldOffset(Person.class.getDeclaredField("name"));
        long ageOffset = unsafe.objectFieldOffset(Person.class.getDeclaredField("age"));

        // 通过unsafe的CAS操作改变值
        unsafe.compareAndSwapObject(person, nameOffset, null, "法外狂徒张三");
        unsafe.compareAndSwapInt(person, ageOffset, 0, 22);
        System.out.println(person);
    }
}

class Person {
    // 配合CAS操作，必须用volatile修饰
    volatile String name;
    volatile int age;

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

Zhang_960110

关注

2
点赞
踩
2

收藏

觉得还不错? 一键收藏
1
评论
CAS与volatile、原子整数、原子引用、原子数组、字段更新器、原子累加器、Unsafe

文章目录1.问题引出1.1 保护共享资源-加锁实现1.2 保护共享资源-无锁实现2.CAS与volatile2.1 CAS工作流程2.2 volatile作用2.3 CAS效率分析2.4 CAS特点3.原子整数4.原子引用4.1 AtomicReference4.2 原子引用-ABA问题4.3 AtomicStampedReference4.4 AtomicMarkableReference5.原子数组1.问题引出1.1 保护共享资源-加锁实现使用synchronized来保证多线程访问共享资源发生的
复制链接

扫一扫

专栏目录