JUC Unsafe

summary
Unsafe Object provides a very low-level , Operating memory 、 Thread method ,Unsafe Object cannot be called directly , Only by reflection

public class UnsafeAccessor {
    
 static Unsafe unsafe;
 static {
    
 try {
     
 Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");
 theUnsafe.setAccessible(true);
 unsafe = (Unsafe) theUnsafe.get(null);
 } catch (NoSuchFieldException | IllegalAccessException e) {
    
 throw new Error(e);
 }
 }
 static Unsafe getUnsafe() {
    
 return unsafe;
 }
}

Unsafe CAS operation

@Data
class Student {
    
 volatile int id;
 volatile String name; }

Unsafe unsafe = UnsafeAccessor.getUnsafe();
Field id = Student.class.getDeclaredField("id");
Field name = Student.class.getDeclaredField("name");
//  Get the offset of the member variable 
long idOffset = UnsafeAccessor.unsafe.objectFieldOffset(id);
long nameOffset = UnsafeAccessor.unsafe.objectFieldOffset(name);
Student student = new Student();
//  Use  cas  Method to replace the value of a member variable 
UnsafeAccessor.unsafe.compareAndSwapInt(student, idOffset, 0, 20); //  return  true
UnsafeAccessor.unsafe.compareAndSwapObject(student, nameOffset, null, " Zhang San "); //  return  true
System.out.println(student);```



```java
class AtomicData {
    
 private volatile int data;
 static final Unsafe unsafe;
 static final long DATA_OFFSET;
 static {
    
 unsafe = UnsafeAccessor.getUnsafe();
 try {
    
 // data  Attribute in  DataContainer  Offset in object , be used for  Unsafe  Access the property directly 
 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) {
    
 //  Get the old value of the shared variable , You can add breakpoints to this line , modify  data  Debug to deepen understanding 
 oldValue = data;
 // cas  Try to modify  data  by   The old value  + amount, If the old value is changed by another thread , return  false
 if (unsafe.compareAndSwapInt(this, DATA_OFFSET, oldValue, oldValue - amount)) {
    
 return;
 }
 }
 }
 public int getData() {
    
 return data;
 }
}