本篇内容介绍了“Java中cas实现原理是什么”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！

网站建设哪家好，找创新互联公司！专注于网页设计、网站建设、微信开发、小程序设计、集团企业网站建设等服务项目。为回馈新老客户创新互联还提供了费县免费建站欢迎大家使用！

java提供了三个CAS操作不安全:

compareAndSwapLong compareAndSwapObject compareAndSwapInt () () ()

//Parameter meaning: object, attribute memory offset, attribute expected value, attribute update valuepublic final native boolean compareAndSwapObject(Object var1, long var2, Object var4, Object var5);public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);public final native boolean compareAndSwapLong(Object var1, long var2, long var4, long var6);

抵消:对象在内存中包含对象头和对象实例数据,和对象头占8个字节。对于64位的操作系统,压缩指针占4个字节,所以我们通常说的对象头占12个字节;例如,测试对象,x的偏置是头的对象,也就是说,12个字节,和y的抵消是16

cas操作修改测试类的变量x。

public class CASTest {    public static void main(String[] args) {
        Test test = new Test();
        Unsafe unsafe = UnsafeFactory.getUnsafe();        long xOffset = UnsafeFactory.getFieldOffset(unsafe, Test.class, "x");
        System.out.println(xOffset); //12
        long yOffset = UnsafeFactory.getFieldOffset(unsafe, Test.class, "y");
        System.out.println(yOffset); //16
        unsafe.compareAndSwapInt(test, xOffset, 0, 1);
        System.out.println(test.x);
    }    
    static class Test {        int x;        int y;
    }
}

能保证原子性,但不能保证秩序和可见性。因此,一般来说,可以用于挥发性,以确保线程安全。底层最后执行CAS指令(原子操作修改变量值)和比较期望值与实际值在内存中。如果比较结果相等,返回旧值(期望值),表明CAS操作成功。如果他们是不平等的,在内存返回实际值,表明CAS操作失败。

CAS实现线程安全的操作

public class CASTest {    private static int sum = 0;    private static CASLock casLock = new CASLock();    public static void main(String[] args) throws InterruptedException {        for (int i=0; i<10; i++) {            new Thread(() -> {                for (;;) {                    if (casLock.getState() == 0 && casLock.cas()) {                        try {                            for (int j = 0; j < 10000; j++) {
                                sum++;
                            }
                        } finally {
                            casLock.setState(0);
                        }                        break;
                    }
                }
            }).start();
        }
        Thread.sleep(2000);
        System.out.println(sum);
    }
}

public class CASLock {    private volatile int state = 0;    private static final Unsafe UNSAFE;    private static final long OFFSET;    static {
        UNSAFE = UnsafeFactory.getUnsafe();
        OFFSET = UnsafeFactory.getFieldOffset(UNSAFE, CASLock.class, "state");
    }    
    public int getState() {        return state;
    }    public void setState(int state) {        this.state = state;
    }    public boolean cas() {        return UNSAFE.compareAndSwapInt(this, OFFSET, 0, 1);
    }
}

原子在jdk类juc下包通过cas是线程安全的。

LongAdder和DoubleAdder原则

在高并发性下,CAS操作将有大量的线程旋转,导致浪费线程资源。为了提高执行效率,V值分为多个变量。多个线程执行CAS操作同时在自己的变量。所有线程完成后执行,所有变量都是积累和统计。它的想法是类似于统计jdk8 ConcurrentHashMap的元素的数量。LongAdder DoubleAdder也实现这个想法。LongAdder定义了基本变量和单元数组变量,初始化并积累单元阵列通过散列,最后积累基础和单元阵列的所有数字的结果。

“Java中cas实现原理是什么”的内容就介绍到这里了，感谢大家的阅读。如果想了解更多行业相关的知识可以关注创新互联网站，小编将为大家输出更多高质量的实用文章！

文章题目：Java中cas实现原理是什么
链接分享：http://kswsj.cn/article/ghcpoo.html