修改对象的字段

  1. package org.example.concurrency.test;
  3. import lombok.Data;
  4. import sun.misc.Unsafe;
  6. import java.lang.reflect.Constructor;
  7. import java.lang.reflect.Field;
  9. /**
  10.  * @author huskyui
  11.  */
  12. public class Test33 {
  13.     public static void main(String[] args) throws Exception {
  14.         Class<?> aClass = Class.forName("sun.misc.Unsafe");
  15.         Constructor<?> declaredConstructor = aClass.getDeclaredConstructors()[0];
  16.         declaredConstructor.setAccessible(true);
  17.         Unsafe unsafe = (Unsafe)declaredConstructor.newInstance(new Object[0]);
  18.         System.out.println(unsafe);
  20.         Student student = new Student();
  21.         Field id = Student.class.getDeclaredField("id");
  22.         Field name = Student.class.getDeclaredField("name");
  23.         long idOffset = unsafe.objectFieldOffset(id);
  24.         long nameOffset = unsafe.objectFieldOffset(name);
  25.         boolean b = unsafe.compareAndSwapInt(student, idOffset, 0, 1);
  26.         System.out.println(unsafe.compareAndSwapObject(student, nameOffset, null, "huskyui"));
  27.         System.out.println(b);
  28.         System.out.println(student);
  32.     }
  33. }
  34. @Data
  35. class Student{
  36.     volatile int id;
  37.     volatile String name;
  38. }

Unsafe需要通过反射反射获取对象。修改对象字段的时候，需要获得字段的offset值

实现一个原子类

  1. package org.example.concurrency.test;
  3. import sun.misc.Unsafe;
  5. import java.lang.reflect.Constructor;
  6. import java.util.ArrayList;
  7. import java.util.List;
  9. /**
  10.  * @author huskyui
  11.  */
  12. public class MyAtomicInteger {
  13.     private volatile int data;
  14.     static Unsafe unsafe = null;
  15.     static long DATA_OFFSET = 0;
  17.     static {
  18.         try {
  19.             Class<?> aClass = Class.forName("sun.misc.Unsafe");
  20.             Constructor<?> declaredConstructor = aClass.getDeclaredConstructors()[0];
  21.             declaredConstructor.setAccessible(true);
  22.             unsafe = (Unsafe) declaredConstructor.newInstance(new Object[0]);
  23.             System.out.println(unsafe);
  24.             DATA_OFFSET = unsafe.objectFieldOffset(MyAtomicInteger.class.getDeclaredField("data"));
  26.         }catch (Exception e){
  27.             e.printStackTrace();
  28.         }
  30.     }
  33.     public MyAtomicInteger(int data) {
  34.         this.data = data;
  35.     }
  37.     public int get(){
  38.         return data;
  39.     }
  41.     public void decrease(int amount){
  42.         while (true) {
  43.             int prev = get();
  44.             int next = prev - amount;
  45.             if (unsafe.compareAndSwapInt(this, DATA_OFFSET, prev, next)){
  46.                 break;
  47.             }
  48.         }
  49.     }
  53.     public static void main(String[] args) {
  54.         MyAtomicInteger myAtomicInteger = new MyAtomicInteger(10000);
  55.         long start = System.nanoTime();
  56.         List<Thread> ts = new ArrayList<>();
  57.         for (int i = 0;i<1000;i++){
  58.             ts.add(new Thread(()->{
  59.                 myAtomicInteger.decrease(10);
  60.             }));
  61.         }
  63.         ts.forEach(Thread::start);
  64.         for (Thread t : ts) {
  65.             try {
  66.                 t.join();
  67.             } catch (InterruptedException e) {
  68.                 e.printStackTrace();
  69.             }
  70.         }
  71.         long cost = System.nanoTime()-start;
  72.         System.out.println("cost" + (cost/1000/10000)+ " amount"  + myAtomicInteger.get());
  77.     }
  79. }