Unsafe学习

概述

概述

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;
    }
}