概述
概述
Unsafe 对象提供了==非常底层的,操作内存、线程==的方法,Unsafe 对象不能直接调用,只能通过反射获得 .
cas、LockSupport、Park&Unpark、原子引用类 都是使用Unsafe类中的方法。
获取Unsafe对象
可以看下Unsafe的源码,它持有一个私有的静态final域:theUnsafe。这个Unsafe类里面的静态代码块中,给theUnsafe赋了值。
我们可以使用下面这个类来获取Unsafe对象。
public class UnsafeAccessor {
static Unsafe unsafe;
static {
try {
Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe"); // 因为theUnsafe是私有的
theUnsafe.setAccessible(true); // 因为私有的,使用暴力反射
unsafe = (Unsafe) theUnsafe.get(null); // 因为theUnsafe是static的,所以跟对象无关
} catch (NoSuchFieldException | IllegalAccessException e) {
throw new Error(e);
}
}
static Unsafe getUnsafe() {
return unsafe;
}
}
Unsafe CAS 操作
public class TestUnsafe {
public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {
// 获取Unsafe类的static域theUnsafe
Unsafe unsafe = UnsafeAccessor.getUnsafe();
Field id = Student.class.getDeclaredField("id");
Field name = Student.class.getDeclaredField("name");
// 获得 成员变量的偏移量
// (如果确定了对象的地址, 那么对象的域相对于对象的地址的偏移量是固定的;)
// (也就是说可以: 通过对象的地址+域相对于对象地址的偏移量,找到这个对象的这个域的内存地址,然后嘿嘿)
long idOffset = UnsafeAccessor.unsafe.objectFieldOffset(id);
long nameOffset = UnsafeAccessor.unsafe.objectFieldOffset(name);
Student student = new Student();
// 使用 cas 方法替换成员变量的值 对象 | 域偏移量 | 期望值| 更新值
UnsafeAccessor.unsafe.compareAndSwapInt(student, idOffset, 0, 20); // 返回 true
UnsafeAccessor.unsafe.compareAndSwapObject(student, nameOffset, null, "张三"); // 返回 true
System.out.println(student);
}
}
@Data
class Student {
volatile int id; // 域须使用volatile修饰,否则unsafe的cas操作,不能保证线程安全
volatile String name;
}
手写原子类
public class TestCustomizedAtomicInteger {
public static void main(String[] args) {
MyAtomicInteger atomicInteger = new MyAtomicInteger();
List<Thread> list = new ArrayList<>();
for (int i = 0; i < 1000; i++) {
list.add(new Thread(() -> {
atomicInteger.add(1);
}));
}
list.forEach(Thread::start);
list.forEach(t -> {
try {
t.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
});
System.out.println(atomicInteger.get());
}
}
class MyAtomicInteger {
private volatile int value;
private static volatile long valueOffset;
private static Unsafe UNSAFE;
static {
try {
// 获取Unsafe类中的private static final theUnsafe属性,它在static静态代码块中赋的值
Field field = Unsafe.class.getDeclaredField("theUnsafe");
// 因为field它是private的
field.setAccessible(true);
// 因为field它是static的,所以不需要依赖对象,而是从属于类
UNSAFE = (Unsafe) field.get(null);
// 关键点: 使用Unsafe对象可以获取任意类中的任何属性的相对于对象地址的偏移量
// (某个域相对于对象地址的偏移量是固定的)
valueOffset = UNSAFE.objectFieldOffset(MyAtomicInteger.class.getDeclaredField("value"));
} catch (NoSuchFieldException | IllegalAccessException e) {
e.printStackTrace();
}
}
public int get() {
return this.value;
}
public void add(int amount) {
while (true) {
int prev = this.value;
int next = this.value + amount;
if (UNSAFE.compareAndSwapInt(this, valueOffset, prev, next)) {
break;
}
}
}
public void reduce(int amount) {
while (true) {
int prev = this.value;
int next = this.value - amount;
if (UNSAFE.compareAndSwapInt(this, valueOffset, prev, next)) {
break;
}
}
}
}
大神实现
class AtomicData {
private volatile int data;
static final Unsafe unsafe; // 这里用final
static final long DATA_OFFSET; // 这里也用final
static {
unsafe = UnsafeAccessor.getUnsafe();
try {
// data 属性在 DataContainer 对象中的偏移量,用于 Unsafe 直接访问该属性
DATA_OFFSET = unsafe.objectFieldOffset(AtomicData.class.getDeclaredField("data"));
} catch (NoSuchFieldException e) {
throw new Error(e); // 这里一定要抛一个非受检异常,日了狗了
}
}
public AtomicData(int data) {
this.data = data;
}
public void decrease(int amount) {
int oldValue;
while(true) {
// 获取共享变量旧值,可以在这一行加入断点,修改 data 调试来加深理解
oldValue = data;
// cas 尝试修改 data 为 旧值 + amount,如果期间旧值被别的线程改了,返回 false
if (unsafe.compareAndSwapInt(this, DATA_OFFSET, oldValue, oldValue - amount)) {
return;
}
}
}
public int getData() {
return data;
}
}