AtomicInteger的使用(高并发)

本文介绍了在高并发场景下,使用AtomicInteger解决计数器++操作的问题。通过对比普通代码和加volatile关键字的效果,展示AtomicInteger如何利用CAS(Compare and Swap)原理确保原子性,从而有效避免数据不一致。实验结果显示AtomicInteger成功解决了并发问题。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

AtomicInteger的使用(高并发)

普通代码处理高并发,对count进行++操作:

public class MyAtomicInteger {
    private static final Integer threadCount = 20;
    private static Integer num = 0;
    private static void increase() {
        num++;
    }

    public static void main(String[] args) {
        Thread[] threads = new Thread[threadCount];
        for (int i = 0; i < threadCount; i++) {
            threads[i] = new Thread(() -> {
                for (int i1 = 0; i1 < 2000; i1++) {
                    increase();
                }
            });
            threads[i].start();
        }
        while (Thread.activeCount() > 1) {
//            意思就是调用yield方法会让当前线程交出CPU权限,让CPU去执行其他的线程。它跟sleep方法类似,同样不会释放锁。
//            但是yield不能控制具体的交出CPU的时间,另外,yield方法只能让拥有相同优先级的线程有获取CPU执行时间的机会。
//            注意调用yield方法并不会让线程进入阻塞状态,而是让线程重回就绪状态,它只需要等待重新获取CPU执行时间,这一点是和sleep方法不一样的
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName());
        System.out.println("num:" + num);
    }
}

运行结果如下:

main
num:36939

正确值应该是40000,但是少了,说明我们的代码有问题
加上volatile修饰count:

public class MyAtomicInteger {
    private static final Integer threadCount = 20;
    private static volatile Integer num = 0;
    private static void increase() {
        num++;
    }

    public static void main(String[] args) {
        Thread[] threads = new Thread[threadCount];
        for (int i = 0; i < threadCount; i++) {
            threads[i] = new Thread(() -> {
                for (int i1 = 0; i1 < 2000; i1++) {
                    increase();
                }
            });
            threads[i].start();
        }
        while (Thread.activeCount() > 1) {
//            意思就是调用yield方法会让当前线程交出CPU权限,让CPU去执行其他的线程。它跟sleep方法类似,同样不会释放锁。
//            但是yield不能控制具体的交出CPU的时间,另外,yield方法只能让拥有相同优先级的线程有获取CPU执行时间的机会。
//            注意调用yield方法并不会让线程进入阻塞状态,而是让线程重回就绪状态,它只需要等待重新获取CPU执行时间,这一点是和sleep方法不一样的
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName());
        System.out.println("num:" + num);
    }
}

结果还是差强人意,结果如下:

main
num:39490

这个时候引入java并发包下的AtomicInteger类,利用其原子操作实现高并发问题解决,代码如下:

public class MyAtomicInteger {
    private static final Integer threadCount = 20;
    private static AtomicInteger count = new AtomicInteger(0);
    private static void increase() {
        count.incrementAndGet();
    }

    public static void main(String[] args) {
        Thread[] threads = new Thread[threadCount];
        for (int i = 0; i < threadCount; i++) {
            threads[i] = new Thread(() -> {
                for (int i1 = 0; i1 < 2000; i1++) {
                    increase();
                }
            });
            threads[i].start();
        }
        while (Thread.activeCount() > 1) {
//            意思就是调用yield方法会让当前线程交出CPU权限,让CPU去执行其他的线程。它跟sleep方法类似,同样不会释放锁。
//            但是yield不能控制具体的交出CPU的时间,另外,yield方法只能让拥有相同优先级的线程有获取CPU执行时间的机会。
//            注意调用yield方法并不会让线程进入阻塞状态,而是让线程重回就绪状态,它只需要等待重新获取CPU执行时间,这一点是和sleep方法不一样的
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName());
        System.out.println("num:" + count);
    }
}

运行结果:

main
num:40000

可见实现了对高并发情况下问题的解决!

实现原理:
利用cas原理,在主存中有一V值,线程在进入的时候会获取到V值,在进行更新的时候,会把自己获取到的V值和主存的V值进行比较,如果相等就进行更新操作,然后返回V的旧值,避免重复更新操作。同时和之前线程同时进来的线程获取的V值就不等于之前线程更新后主存中的V值了,就不能实现更新操作。但是,会利用while循环
while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4)); 不断地把主存中的V值更新成自己的V值,当相等的时候,实现更新操作,从而解决高并发问题。这就是无锁环境下的并发控制,效率高于qas锁,称为乐观锁。。

以上是博主的学习过程,如有不妥之处,望指正!!!!!

评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值