本文的内容
- Unsafe基本介绍
- 获取Unsafe实例
- Unsafe中的CAS操作
- Unsafe中原子操作相关方法介绍
- Unsafe中线程调度先关方法介绍
- park和unpark示例
- Unsafe锁示例
- Unsafe中对volatile的支持
基本介绍
最新我们一直在学习java高并发，java高并发中主要涉及到类位于juc包中，juc中大部分类都是依赖于Unsafe来实现的，主要用到了Unsafe中的CAS，线程挂起，线程恢复等相关功能。所以如果打算深入了解juc原理，必须先了解Unsafe类
先上一幅Unsafe类的功能图：
从Unsafe功能图上看出，Unsafe提供的API大致可分为内存操作、CAS、Class相关、对象操作、线程调度、系统信息获取、内存屏障、数组操作等几类，本文主要介绍3个常用的操作：CAS、线程调度、对象操作。
看一下UnSafe的原码部分：
@CallerSensitive
public static Unsafe getUnsafe() {
Class var0 = Reflection.getCallerClass();
// 仅在引导类加载器`BootstrapClassLoader`加载时才合法
if (!VM.isSystemDomainLoader(var0.getClassLoader())) {
throw new SecurityException("Unsafe");
} else {
return theUnsafe;
}
}从代码中可以看出，Unsafe类为单例实现，提供静态方法getUnsafe获取Unsafe实例，内部会判断当前调用者是否是由系统类加载器加载的，如果不是系统类加载器加载的，会抛出SecurityException异常。
那我们想使用这个类，如何获取呢？
我们学过反射，通过反射可以获取到Unsafe中的theUnsafe字段的值，这样可以获取到Unsafe对象的实例。
通过反射获取Unsafe实例
public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {
Field field = Unsafe.class.getDeclaredField("theUnsafe");
field.setAccessible(true);
Unsafe unsafe = (Unsafe) field.get(null);
System.out.println(unsafe);
}输出：
sun.misc.Unsafe@6d1e7682Unsafe中CAS操作
看一下Unsafe中的CAS相关方法定义：
/**
* CAS 操作
*
* @param o 包含要修改field的对象
* @param offset 对象中某field的偏移量
* @param expected 期望值
* @param update 更新值
* @return true | false
*/
public final native boolean compareAndSwapObject(Object o, long offset, Object expected, Object update);
public final native boolean compareAndSwapInt(Object o, long offset, int expected,int update);
public final native boolean compareAndSwapLong(Object o, long offset, long expected, long update);我们都知道，CAS是一条CPU的原子指令（cmpxchg指令），不会造成所谓的数据不一致问题，Unsafe提供的CAS方法（如compareAndSwapXXX）底层实现即为CPU指令cmpxchg。执行cmpxchg指令的时候，会判断当前系统是否为多核系统，如果是就给总线加锁，只有一个线程会对总线加锁成功，加锁成功之后会执行cas操作，也就是说CAS的原子性实际上是CPU实现的， 其实在这一点上还是有排他锁的，只是比起用synchronized， 这里的排他时间要短的多， 所以在多线程情况下性能会比较好。
说一下offset，offeset为字段的偏移量，每个对象有个地址，offset是字段相对于对象地址的偏移量，对象地址记为baseAddress，字段偏移量记为offeset，那么字段对应的实际地址就是baseAddress+offeset，所以cas通过对象、偏移量就可以去操作字段对应的值了。
CAS在java.util.concurrent.atomic相关类、Java AQS、JUC中并发集合等实现上有非常广泛的应用，我们看一下java.util.concurrent.atomic.AtomicInteger类，这个类可以在多线程环境中对int类型的数据执行高效的原子修改操作，并保证数据的正确性。大家可以自己看一下源码，很好理解。
Unsafe中原子操作相关方法介绍
5个方法，看一下实现：
/**
* int类型值原子操作，对var2地址对应的值做原子增加操作(增加var4)
*
* @param var1 操作的对象
* @param var2 var2字段内存地址偏移量
* @param var4 需要加的值
* @return
*/
public final int getAndAddInt(Object var1, long var2, int var4) {
int var5;
do {
var5 = this.getIntVolatile(var1, var2);
} while (!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
return var5;
}
/**
* long类型值原子操作，对var2地址对应的值做原子增加操作(增加var4)
*
* @param var1 操作的对象
* @param var2 var2字段内存地址偏移量
* @param var4 需要加的值
* @return 返回旧值
*/
public final long getAndAddLong(Object var1, long var2, long var4) {
long var6;
do {
var6 = this.getLongVolatile(var1, var2);
} while (!this.compareAndSwapLong(var1, var2, var6, var6 + var4));
return var6;
}
/**
* int类型值原子操作方法，将var2地址对应的值置为var4
*
* @param var1 操作的对象
* @param var2 var2字段内存地址偏移量
* @param var4 新值
* @return 返回旧值
*/
public final int getAndSetInt(Object var1, long var2, int var4) {
int var5;
do {
var5 = this.getIntVolatile(var1, var2);
} while (!this.compareAndSwapInt(var1, var2, var5, var4));
return var5;
}
/**
* long类型值原子操作方法，将var2地址对应的值置为var4
*
* @param var1 操作的对象
* @param var2 var2字段内存地址偏移量
* @param var4 新值
* @return 返回旧值
*/
public final long getAndSetLong(Object var1, long var2, long var4) {
long var6;
do {
var6 = this.getLongVolatile(var1, var2);
} while (!this.compareAndSwapLong(var1, var2, var6, var4));
return var6;
}
/**
* Object类型值原子操作方法，将var2地址对应的值置为var4
*
* @param var1 操作的对象
* @param var2 var2字段内存地址偏移量
* @param var4 新值
* @return 返回旧值
*/
public final Object getAndSetObject(Object var1, long var2, Object var4) {
Object var5;
do {
var5 = this.getObjectVolatile(var1, var2);
} while (!this.compareAndSwapObject(var1, var2, var5, var4));
return var5;
}看一下上面的方法，内部通过自旋的CAS操作实现的，这些方法都可以保证操作的数据在多线程环境中的原子性，正确性。
来个示例，我们还是来实现一个网站计数功能，同时有100个人发起对网站的请求，每个人发起10次请求，每次请求算一次，最终结果是1000次，代码如下：
public class Demo1 {
static Unsafe unsafe;
//用来记录网站访问量，每次访问+1
static int count;
//count在Demo.class对象中的地址偏移量
static long offset;
static {
Field field = null;
try {
field = Unsafe.class.getDeclaredField("theUnsafe");
field.setAccessible(true);
unsafe = (Unsafe) field.get(null);
Field declaredField = Demo1.class.getDeclaredField("count");
declaredField.setAccessible(true);
//获取该字段的偏移量
offset = unsafe.staticFieldOffset(declaredField);
} catch (NoSuchFieldException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
public static void main(String[] args) throws InterruptedException {
long starTime = System.currentTimeMillis();
int threadSize = 100;
CountDownLatch countDownLatch = new CountDownLatch(threadSize);
for (int i = 0; i < threadSize; i++) {
Thread thread = new Thread(() -> {
try {
for (int j = 0; j < 10; j++) {
request();
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
countDownLatch.countDown();
}
});
thread.start();
}
countDownLatch.await();
long endTime = System.currentTimeMillis();
System.out.println(Thread.currentThread().getName() + "，耗时：" + (endTime - starTime) + ",count=" + count);
}
//模拟访问一次
public static void request() throws InterruptedException {
//模拟耗时5毫秒
TimeUnit.MILLISECONDS.sleep(5);
//对count原子加1
unsafe.getAndAddInt(Demo1.class, offset, 1);
}
}输出：
main，耗时：145,count=1000代码中我们在静态块中通过反射获取到了Unsafe类的实例，然后获取Demo1中count字段内存地址偏移量offset，main方法中模拟了100个人，每人发起10次请求，等到所有请求完毕之后，输出count的结果。
代码中用到了CountDownLatch，通过countDownLatch.await()让主线程等待，等待100个子线程都执行完毕之后，主线程在进行运行。CountDownLatch的使用可以参考：线程系列- CountDownLatch 文章
Unsafe中线程调度相关方法
这部分，包括线程挂起、恢复、锁机制等方法。
//取消阻塞线程
public native void unpark(Object thread);
//阻塞线程,isAbsolute：是否是绝对时间，如果为true，time是一个绝对时间，如果为false，time是一个相对时间，time表示纳秒
public native void park(boolean isAbsolute, long time);
//获得对象锁（可重入锁）
@Deprecated
public native void monitorEnter(Object o);
//释放对象锁
@Deprecated
public native void monitorExit(Object o);
//尝试获取对象锁
@Deprecated
public native boolean tryMonitorEnter(Object o);调用park后，线程将被阻塞，直到unpark调用或者超时，如果之前调用过unpark,不会进行阻塞，即park和unpark不区分先后顺序。monitorEnter、monitorExit、tryMonitorEnter 3个方法已过期，不建议使用了。
park和unpark示例
public class Demo2 {
static Unsafe unsafe;
static {
Field field = null;
try {
field = Unsafe.class.getDeclaredField("theUnsafe");
field.setAccessible(true);
unsafe = (Unsafe) field.get(null);
} catch (NoSuchFieldException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
public static void main(String[] args) throws InterruptedException {
Thread thread = new Thread(() -> {
System.out.println(System.currentTimeMillis());
unsafe.park(false, TimeUnit.SECONDS.toNanos(3));
System.out.println("park:" + System.currentTimeMillis());
});
thread.start();
TimeUnit.SECONDS.sleep(5);
unsafe.unpark(thread);
System.out.println("main:" + System.currentTimeMillis());
}
}输出：
1608192612615
park:1608192615617
main:1608192617617Unsafe锁
public class Demo3 {
static Unsafe unsafe;
static int count;
static {
Field field = null;
try {
field = Unsafe.class.getDeclaredField("theUnsafe");
field.setAccessible(true);
unsafe = (Unsafe) field.get(null);
} catch (NoSuchFieldException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
public static void main(String[] args) throws InterruptedException {
for (int i = 0; i < 100; i++) {
new Thread(()->{
addCount();
}).start();
}
System.out.println(count);
}
static void addCount(){
unsafe.monitorEnter(Demo3.class);
count++;
unsafe.monitorExit(Demo3.class);
}
}输出：
99注意：
-
monitorEnter、monitorExit、tryMonitorEnter 3个方法已过期，不建议使用了
-
monitorEnter、monitorExit必须成对出现，出现的次数必须一致，也就是说锁了n次，也必须释放n次，否则会造成死锁
Unsafe中保证变量的可见性
java中操作内存分为主内存和工作内存。共享数据在住内存中，线程如果需要操作主内存的数据，需要先将主内存的数据复制到线程独有的工作内存中，操作完成之后再将其舒心到主内存中。如线程A要想看到线程B修改后的数据，需要满足：线程B修改数据之后，需要将数据从自己的工作内存中刷新到主内存中，并且A需要去主内存中读取数据。
被关键字volatile修饰的数据，有2点语义：
- 如果一个变量被volatile修饰，读取这个变量时候，会强制从主内存中读取，然后将其复制到当前线程的工作内存中
- 给volatile修饰的变量赋值的时候，会强制将赋值的结果从工作内存刷新到主内存中
上面2点语义保证了被volatile修饰的数据在多线程中的可见性
Unsafe中提供了和volatile语义一样的功能方法：
//设置给定对象的int值，使用volatile语义，即设置后立马更新到内存对其他线程可见
public native void putIntVolatile(Object o, long offset, int x);
//获得给定对象的指定偏移量offset的int值，使用volatile语义，总能获取到最新的int值。
public native int getIntVolatile(Object o, long offset);o：表示需要操作的对象
offset：表示操作对象中的某个字段地址偏移量
x：将offset对应的字段的值修改为x，并且立即刷新到主存中
调用这个方法，会强制将工作内存中修改的数据刷新到主内存中。
扫一扫
254
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
