并发编程4-CAS和魔术类Unsafe

public class Test {
    private static AtomicInteger atomicInt = new AtomicInteger(100);
    private static AtomicStampedReference atomicStampedRef = new AtomicStampedReference(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();
}

UnSafe类详解

基本介绍 Java魔法类：Unsafe应用解析https://tech.meituan.com/2019/02/14/talk-about-java-magic-class-unsafe.html

Java魔法类：Unsafe应用解析https://tech.meituan.com/2019/02/14/talk-about-java-magic-class-unsafe.html

Unsafe是位于sun.misc包下的一个类，主要提供一些用于执行低级别、不安全操作的方法，如直接访问系统内存资源、自主管理内存资源等，

这些方法在提升Java运行效率、增强Java语言底层资源操作能力方面起到了很大的作用。

但由于Unsafe类使Java语言拥有了类似C语言指针一样操作内存空间的能力，这无疑也增加了程序发生相关指针问题的风险。

在程序中过度、不正确使用Unsafe类会使得程序出错的概率变大，使得Java这种安全的语言变得不再“安全”，因此对Unsafe的使用一定要慎重。

Unsafe类:：通过单例模式实现，提供静态方法getUnsafe获取Unsafe实例，当且仅当调用getUnsafe方法的类为引导类加载器所加载时才合法，否则抛出SecurityException异常。所以尽管里面的方法都是 public 的，但是并没有办法使用它们，如下Unsafe源码所示：

public final class Unsafe {
  private static final Unsafe theUnsafe;
  private Unsafe() { }
  @CallerSensitive
  public static Unsafe getUnsafe() {
    Class classload = Reflection.getCallerClass();
    if(!VM.isSystemDomainLoader(classload.getClassLoader())) {     // 当且仅当调用getUnsafe方法的类为引导类加载器所加载时才合法，否则抛出SecurityException异常
      throw new SecurityException("Unsafe");
    } else {
      return theUnsafe;
    }
  }
}

如何获取Unsafe实例？

1、从getUnsafe方法的使用限制条件出发，

通过Java命令行命令-Xbootclasspath/a把调用Unsafe相关方法的类A所在jar包路径追加到默认的bootstrap路径中，

使得A被引导类加载器加载，从而通过Unsafe.getUnsafe方法安全的获取Unsafe实例。 java Xbootclasspath/a:${path} // 其中path为调用Unsafe相关方法的类所在jar包路径

2.通过反射获取单例对象theUnsafe

public class UnsafeInstance { 
    public static Unsafe reflectGetUnsafe() { 
    	try {
     		Field field =  Unsafe.class.getDeclaredField("theUnsafe");
     		field.setAccessible(true); 
    		return (Unsafe) field.get(null); 
    	} catch (Exception e) { 
    		e.printStackTrace(); 
    	}
    return null; 
    } 
}

Unsafe 类可用于操作：

API方法介绍：

1.CAS操作相关 :

完成原子操作，底层通过汇编指令 cmpxchg 实现

API方法介绍：

参数列表：
@param o         包含要修改field的对象
@param offset    对象中某field的偏移量
@param expected  期望值 
@param update    更新值
@return          true | false
  
public final native boolean compareAndSwapObject(Object paramObject1, long paramLong, Object paramObject2, Object paramObject3);

public final native boolean compareAndSwapInt(Object paramObject, long paramLong, int paramInt1, int paramInt2);

public final native boolean compareAndSwapLong(Object paramObject, long paramLong1, long paramLong2, long paramLong3);
 
思考一下：以上三个方法  如果实现 boolean  Dubbo 等其他类型的CAS 操作呢？   通过进行类型转换。 那么又是如何实现类型转换的呢？ 有趣哦

Unsafe底层如何实现CAS？

不妨再看看Unsafe的compareAndSwap*方法来实现CAS操作，它是一个本地方法，实现位于unsafe.cpp中。

UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSwapInt(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jint e, jint x))
  UnsafeWrapper("Unsafe_CompareAndSwapInt");
  oop p = JNIHandles::resolve(obj);
  jint* addr = (jint *) index_oop_from_field_offset_long(p, offset);
  return (jint)(Atomic::cmpxchg(x, addr, e)) == e;
UNSAFE_END

可以看到它通过汇编指令： Atomic::cmpxchg 来实现比较和替换操作。其中参数x是即将更新的值，参数e是原内存的值。 addr 为偏移量

Unsafe的CAS 典型应用

CAS在java.util.concurrent.atomic相关类、AQS、CurrentHashMap等实现上有非常广泛的应用。

如在AtomicInteger的实现中，静态字段valueOffset即为字段value的内存偏移地址，

valueOffset的值在AtomicInteger初始化时，在静态代码块中通过Unsafe的objectFieldOffset方法获取。

在AtomicInteger中提供的线程安全方法中，通过字段valueOffset的值可以定位到AtomicInteger对象中value的内存地址，从而可以根据CAS实现对value字段的原子操作。

public class AtomicInteger extends Number implements java.io.Serializable {
    private static final long serialVersionUID = 6214790243416807050L;

    // setup to use Unsafe.compareAndSwapInt for updates
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private static final long valueOffset; //字段value的内存偏移地址

    static {
        try {
            // 通过字段valueOffset的值可以定位到AtomicInteger对象中value的内存地址
            valueOffset = unsafe.objectFieldOffset
                (AtomicInteger.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }
 	........
}

2.线程调度 (重点)

线程挂起恢复获取锁释放锁

方法park、unpark即可实现线程的挂起与恢复，

将一个线程进行挂起是通过park方法实现的，调用park方法后，线程将一直阻塞直到超时或者中断等条件出现；

unpark 可以终止一个挂起的线程，使其恢复正常。

API方法介绍：

public native void park(boolean isAbsolute, long time); //阻塞线程 挂起
public native void unpark(Object thread); //取消阻塞线程 
public native void monitorEnter(Object o); //获得对象锁（可重入锁）
public native void monitorExit(Object o); //释放对象锁
public native boolean tryMonitorEnter(Object o);//尝试获取对象锁

典型应用: AbstractQueuedSynchronizer 中很多实现都是基于Unsafe 操作线程底层；

典型应用

其一：Java锁和同步器框架的核心类AbstractQueuedSynchronizer，就是通过调用 LockSupport.park()和LockSupport.unpark()实现线程的阻塞和唤醒的，

而LockSupport的park、unpark方法实际是调用Unsafe的park、unpark方式来实现。

其二：通过Unsafe的monitorEnter、monitorExit方法可以实现跨方法同步机制

3.内存屏障：

在Java 8中引入，用于定义内存屏障（也称内存栅栏，内存栅障，屏障指令等，是一类同步屏障指令，是CPU或编译器在对内存随机访问的操作中的一个同步点，使得此点之前的所有读写操作都执行后才可以开始执行此点之后的操作），避免代码重排序

API方法介绍：

//内存屏障，禁止load操作重排序。屏障前的load操作不能被重排序到屏障后，屏障后的load操作不能被重排序到屏障前
public native void loadFence();
//内存屏障，禁止store操作重排序。屏障前的store操作不能被重排序到屏障后，屏障后的store操作不能被重排序到屏障前
public native void storeFence();
//内存屏障，禁止load、store操作重排序
public native void fullFence();

典型应用

在Java 8中引入了一种锁的新机制——StampedLock，它可以看成是读写锁的一个改进版本。 (stamped 英[stæmpt] 美[stæmpt] adj. (信封或包裹)贴好邮票的; v. 在…上盖(字样或图案等); 把(字样或图案等)盖在…上; ）

StampedLock提供了一种乐观读锁的实现，这种乐观读锁类似于无锁的操作，完全不会阻塞写线程获取写锁，从而缓解读多写少时写线程“饥饿”现象。

由于StampedLock提供的乐观读锁不阻塞写线程获取读锁，当线程共享变量从主内存load到线程工作内存时，会存在数据不一致问题，所以当使用StampedLock的乐观读锁时，需要遵从如下图用例中使用的模式来确保数据的一致性。

如上图用例所示计算坐标点Point对象，包含点移动方法move及计算此点到原点的距离的方法distanceFromOrigin。在方法distanceFromOrigin中，首先，通过 tryOptimisticRead方法获取乐观读标记；然后从主内存中加载点的坐标值 (x,y)；而后通过 StampedLock的validate方法校验锁状态，判断坐标点(x,y)从主内存加载到线程工作内存过程中，主内存的值是否已被其他线程通过move方法修改，如果validate返回值为true，证明(x, y)的值未被修改，可参与后续计算；否则，需加悲观读锁，再次从主内存加载(x,y) 的最新值，然后再进行距离计算。其中，校验锁状态这步操作至关重要，需要判断锁状态是否发生改变，从而判断之前copy到线程工作内存中的值是否与主内存的值存在不一致。下图为StampedLock.validate方法的源码实现，通过锁标记与相关常量进行位运算、比较来校验锁状态，在校验逻辑之前，会通过Unsafe的loadFence方法加入一个load内存屏障，目的是避免上图用例中步骤②和StampedLock.validate中锁状态校验运算发生重排序导致锁状态校验不准确的问题

4.堆外内存操作

这部分主要包含分配扩充释放拷贝堆外内存设置/获取给定地址中的值

API方法介绍：

public native long allocateMemory(long bytes); //分配内存, 相当于C++的malloc函数
public native long reallocateMemory(long address, long bytes);//扩充内存
public native void freeMemory(long address);//释放内存
public native void copyMemory(Object srcBase, long srcOffset, Object destBase, long destOffset, long bytes);//内存拷贝
public native void setMemory(Object o, long offset, long bytes, byte value);//在给定的内存块中设置值
// 获取给定地址值，忽略修饰限定符的访问限制。与此类似操作还有: getInt，getDouble，getLong，getChar等
public native Object getObject(Object o, long offset);
//为给定地址设置值，忽略修饰限定符的访问限制，与此类似操作还有: putInt,putDouble，putLong，putChar等
public native void putObject(Object o, long offset, Object x);
/ /获取给定地址的byte类型的值（当且仅当该内存地址为allocateMemory分配时，此方法结果为确定的）
public native byte getByte(long address);
// 为给定地址设置byte类型的值（当且仅当该内存地址为allocateMemory分配时，此方法结果才是确定的）
public native void putByte(long address, byte x);

通常，我们在Java中创建的对象都处于堆内内存（heap）中，堆内内存是由JVM所管控的Java进程内存，并且它们遵循JVM的内存管理机制，JVM会采用垃圾回收机制统一管理堆内内存。

与之相对的是堆外内存，存在于JVM管控之外的内存区域，Java中对堆外内存的操作，依赖于Unsafe提供的操作堆外内存的native方法。

使用堆外内存的原因

对垃圾回收停顿的改善。由于堆外内存是直接受操作系统管理而不是JVM，所以当我们使用堆外内存时，即可保持较小的堆内内存规模。从而在GC时减少回收停顿对于应用的影响。
提升程序I/O操作的性能。通常在I/O通信过程中，会存在堆内内存到堆外内存的数据拷贝操作，对于需要频繁进行内存间数据拷贝且生命周期较短的暂存数据，都建议存储到堆外内存。

典型应用

DirectByteBuffer是Java用于实现堆外内存的一个重要类，通常用在通信过程中做缓冲池，如在Netty、MINA等NIO框架中应用广泛。

DirectByteBuffer对于堆外内存的创建、使用、销毁等逻辑均由Unsafe提供的堆外内存API来实现。

通过Unsafe.allocateMemory分配内存、Unsafe.setMemory进行内存初始化，而后构建Cleaner对象用于跟踪DirectByteBuffer对象的垃圾回收，

以实现当DirectByteBuffer被垃圾回收时，分配的堆外内存一起被释放。部分源码：

DirectByteBuffer(int cap) {                   // package-private
    super(-1, 0, cap, cap);
    boolean pa = VM.isDirectMemoryPageAligned();
    int ps = Bits.pageSize();
    long size = Math.max(1L, (long)cap + (pa ? ps : 0));
    Bits.reserveMemory(size, cap);
    long base = 0;
    try {
        base = unsafe.allocateMemory(size); // 获取内存
    } catch (OutOfMemoryError x) {
        Bits.unreserveMemory(size, cap);
        throw x;
    }
    unsafe.setMemory(base, size, (byte) 0); // 设置内存
    if (pa && (base % ps != 0)) {
        // Round up to page boundary
        address = base + ps - (base & (ps - 1));
    } else {
        address = base;
    }
    cleaner = Cleaner.create(this, new Deallocator(base, size, cap)); // 构建Cleaner对象用于跟踪DirectByteBuffer对象的垃圾回收，以实现当DirectByteBuffer被垃圾回收时，分配的堆外内存一起被释放
    att = null;

.........

其他的功能点请自行查阅源码

都要好好的O

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
并发编程4-CAS和魔术类Unsafe

¶什么是CASCAS的全称为Compare-And-Swap，直译就是对比交换。是一条CPU的原子指令，其作用是让CPU先进行比较两个值是否相等，然后原子地更新某个位置的值，经过调查发现，其实现方式是基于硬件平台的汇编指令，就是说CAS是靠硬件实现的，JVM只是封装了汇编调用，那些AtomicInteger类便是使用了这些封装后的接口。CAS 操作包含三个操作数 —— 内存位置（V）、预期原值（A）和新值(B)。如果内存位置的值与预期原值相匹配，那么处理器会自动将该位置值更新为新值。否则，处理器不
复制链接

扫一扫

专栏目录