java应用CAS

  CAS(Compare and Swap),即比较并替换。jdk里的大量源码通过CAS来提供线程安全操作,比如AtomicInteger类。下面我们来分析一下AtomicInteger是如何在多线程的环境下保证线程安全的。在AtomicInteger里定义了用于存值的value变量,与用于操作value的Unsafe以及value变量的偏移量。源码如下:

public class AtomicInteger extends Number implements java.io.Serializable {
//unsafe来保证改变value的值是线程安全的
    private static final Unsafe unsafe = Unsafe.getUnsafe();
//value值的偏移量
    private static final long valueOffset;
//类初使化的时候通过unsafe能够得到变量的偏移量
  static {
        try {
            valueOffset = unsafe.objectFieldOffset
                (AtomicInteger.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }
//这里声明为volatile,保证了线程间的可见性。
    private volatile int value;

}

我们来分析一下AtomicInteger 做累加操作的源码:

//jdk的源码完全依赖于unsafe的操作。在这里需要传入的是当前对象, value的偏移量,和修改后的值
    public final int getAndSet(int newValue) {
        return unsafe.getAndSetInt(this, valueOffset, newValue);
    }

可以看出完全依赖于unsafe来完成线程安全,那unsafe类里是如何做的呢,截图如下:

Unsafe里如何修改值

在Eclipse默认是看不到sun的源码的,需要下载open jdk的源码进行关联,下载链接:https://github.com/keerath/openjdk-8-source。   采用CAS操作的前题假设是数据竟争不是很严重的情况,如果有大量的线程并发,while里的循环可能就要跑的时间很长了。那除了通过Unsafe类来实现CAS操作,我们还有其它的选择么?必竟Unsafe处于sun的包下面,一般的应用最好不依赖于这个包下面的类。

Atomic*FieldUpdater

中间的*可以是Integer, Long, Reference(引用类型)。我们可以利用JDK给我们提供的API来实现CAS的操作。比如下面的小例子就实现了线程安全,代码如下:

import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;

public class AtomicTest {
//这里的变量需要设置成volatile
    private volatile int                                      lock = 0;

    public static final AtomicIntegerFieldUpdater<AtomicTest> lockUpdate = AtomicIntegerFieldUpdater.newUpdater(AtomicTest.class, "lock");

    public int add(int i) {
        return lockUpdate.addAndGet(this, i);
    }
    
    public int get(){
        return lockUpdate.get(this);
    }

    public static void main(String[] args) throws InterruptedException {
        AtomicTest test = new AtomicTest();
        for (int i = 0; i < 10; i++) {
            Thread t = new Thread(new Runnable() {
                @Override
                public void run() {
                    for(int j=0; j<100; j++){
                        test.add(1);
                    }
                }

            });
            t.start();
        }
        //这里sleep 1秒,等待上面线程跑完,实际代码不能这么写,可以用CountDownLatch
        Thread.currentThread().sleep(1000);
//这里会输出1000
        System.out.println(test.get());

    }
}

AtomicIntegerFieldUpdater内部通过反身,得到需要操作的字段,同样是利用Unsafe类来实现CAS的操作,newUpdater相关源码如下:

//这个类是abstract, 不能构造对象
public abstract class AtomicIntegerFieldUpdater<T> {

    @CallerSensitive
    public static <U> AtomicIntegerFieldUpdater<U> newUpdater(Class<U> tclass,
                                                              String fieldName) {
//返回的是AtomicIntegerFieldUpdaterImpl对象
        return new AtomicIntegerFieldUpdaterImpl<U>
            (tclass, fieldName, Reflection.getCallerClass());
    }

//这个类外部不能够访问,属于private
  private static class AtomicIntegerFieldUpdaterImpl<T>
            extends AtomicIntegerFieldUpdater<T> {
//通过Unsafe来实现CAS的操作
        private static final Unsafe unsafe = Unsafe.getUnsafe();
//传入filed的偏移量
        private final long offset;
        private final Class<T> tclass;
        private final Class<?> cclass;
//上面会调用的构造方法
        AtomicIntegerFieldUpdaterImpl(final Class<T> tclass,
                                      final String fieldName,
                                      final Class<?> caller) {
            final Field field;
            final int modifiers;
            try {
//通过反射得到对应的Feld
                field = AccessController.doPrivileged(
                    new PrivilegedExceptionAction<Field>() {
                        public Field run() throws NoSuchFieldException {
                            return tclass.getDeclaredField(fieldName);
                        }
                    });
                modifiers = field.getModifiers();
                sun.reflect.misc.ReflectUtil.ensureMemberAccess(
                    caller, tclass, null, modifiers);
                ClassLoader cl = tclass.getClassLoader();
                ClassLoader ccl = caller.getClassLoader();
                if ((ccl != null) && (ccl != cl) &&
                    ((cl == null) || !isAncestor(cl, ccl))) {
                  sun.reflect.misc.ReflectUtil.checkPackageAccess(tclass);
                }
            } catch (PrivilegedActionException pae) {
                throw new RuntimeException(pae.getException());
            } catch (Exception ex) {
                throw new RuntimeException(ex);
            }

            Class<?> fieldt = field.getType();
            if (fieldt != int.class)
                throw new IllegalArgumentException("Must be integer type");
//需要声明为volatile
            if (!Modifier.isVolatile(modifiers))
                throw new IllegalArgumentException("Must be volatile type");

            this.cclass = (Modifier.isProtected(modifiers) &&
                           caller != tclass) ? caller : null;
            this.tclass = tclass;
//通过unsafe得到偏移量
            offset = unsafe.objectFieldOffset(field);
        }
}


}
CAS的ABA问题

CAS的算法通过判断内存的值是否与原值相等来进行修改操作,这就有可能会发生下面的问题。

ABA问题

如果场景是和过程状态无关的,只跟结果有关系,那么影响不大,但是有些情况之下,场景可能和过程有关的.当你对数据变化过程是敏感的时候,普通的CAS操作是无法辨别上图2个A的区别的。Java提供了AtomicStampedReference类用于处理ABA的问题,他通过类似版本号的机制来验证数据是否经过更改,用法如下:

//代码来源:https://blog.csdn.net/a67474506/article/details/48310515
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicStampedReference;

public class ABA {
    private static AtomicInteger          atomicInt        = new AtomicInteger(100);
    
    private static AtomicStampedReference<Integer> atomicStampedRef = new AtomicStampedReference<Integer>(100, 0);

    public static void main(String[] args) throws InterruptedException {
        Thread intT1 = new Thread(new Runnable() {
            @Override
            public void run() {
                atomicInt.compareAndSet(100, 101);
                atomicInt.compareAndSet(101, 100);
            }
        });

        Thread intT2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                }
                boolean c3 = atomicInt.compareAndSet(100, 101);
                System.out.println(c3); // true
            }
        });

        intT1.start();
        intT2.start();
        intT1.join();
        intT2.join();

        Thread refT1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                }
                atomicStampedRef.compareAndSet(100, 101, atomicStampedRef.getStamp(), atomicStampedRef.getStamp() + 1);
                atomicStampedRef.compareAndSet(101, 100, atomicStampedRef.getStamp(), atomicStampedRef.getStamp() + 1);
            }
        });

        Thread refT2 = new Thread(new Runnable() {
            @Override
            public void run() {
                int stamp = atomicStampedRef.getStamp();
                try {
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) {
                }
                boolean c3 = atomicStampedRef.compareAndSet(100, 101, stamp, stamp + 1);
                System.out.println(c3); // false
            }
        });

        refT1.start();
        refT2.start();
    }
}

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • Spring Boot读取配置文件与配置文件优先级

    1)通过注入ApplicationContext 或者 Environment对象来读取配置文件里的配置信息。

    良辰美景TT
  • Netty ByteBuf源码解读

      Netty里的ByteBuf主要用于发送或接收消息。在JDK里有相似功能的类java.nio.ByteBuffer。由于JDK在设计ByteBuffer A...

    良辰美景TT
  • 深入分析Spring MVC中RequestBody与ResponseBody

      在SpringMVC中,可以使用@RequestBody和@ResponseBody两个注解,分别完成请求报文到对象和对象到响应报文的转换。在Sprin...

    良辰美景TT
  • android使用LruCache对listview加载图片时候优化处理

    注意:LruCache是有版本限制的,低版本的sdk需要在libs文件夹添加相应的support-4v文件。 本文改造的大部分是参考http://www.i...

    xiangzhihong
  • JAVA虚拟机关闭钩子(Shutdown Hook)

    当你认真的去看一个组件的源码的时候,你会经常看见这种关闭钩子的函数,如果你不了解的话,谷歌一下,你就会发现如下文章就是搜索引擎出来的第一篇,不愧是出自我们优秀的...

    zhisheng
  • 封装自己的dapper lambda扩展-设计篇

    昨天开源了业务业余时间自己封装的dapper lambda扩展,同时写了篇博文《编写自己的dapper lambda扩展-使用篇》简单的介绍了下其使用,今天将分...

    陈珙
  • 对于Android业务开发的一些理解总结

    关于 PopupWindow ,很多博客有谈到利用 Builder 设计模式的链式写法,以下是我项目中的类似写法

    萬物並作吾以觀復
  • 一步步封装实现自己的网络请求框架

    现如今 Android 领域流行的网络请求框架基本都是用 Retrofit 加 RxJava 来搭配构建的,而以 ViewModel + LiveData + ...

    叶应是叶
  • 如何创建多线程

    Wait: 等待状态,没有通过notify 或者 notifyAll 唤醒,就会一直进行等待。

    chaplinthink
  • RecyclerView 使用总结

    自定义类继承 RecyclerView.ItemDecoration,重写回调方法

    七适散人

扫码关注云+社区

领取腾讯云代金券