2. 程式人生 > 程式設計 >Java Unsafe類實現原理及測試程式碼

Java Unsafe類實現原理及測試程式碼

阿新 • • 發佈：2020-09-15

Unsafe類介紹

第一次看到這個類時被它的名字嚇到了，居然還有一個類自名Unsafe？讀完本文，大家也能發現Unsafe類確實有點不那麼安全，它能實現一些不那麼常見的功能。

Unsafe類使Java擁有了像C語言的指標一樣操作記憶體空間的能力，同時也帶來了指標的問題。過度的使用Unsafe類會使得出錯的機率變大，因此Java官方並不建議使用的，官方文件也幾乎沒有。Oracle正在計劃從Java 9中去掉Unsafe類，如果真是如此影響就太大了。

Unsafe類提供了以下這些功能：

一、記憶體管理。包括分配記憶體、釋放記憶體等。

該部分包括了allocateMemory（分配記憶體）、reallocateMemory（重新分配記憶體）、copyMemory（拷貝記憶體）、freeMemory（釋放記憶體 ）、getAddress（獲取記憶體地址）、addressSize、pageSize、getInt（獲取記憶體地址指向的整數）、getIntVolatile（獲取記憶體地址指向的整數，並支援volatile語義）、putInt（將整數寫入指定記憶體地址）、putIntVolatile（將整數寫入指定記憶體地址，並支援volatile語義）、putOrderedInt（將整數寫入指定記憶體地址、有序或者有延遲的方法）等方法。getXXX和putXXX包含了各種基本型別的操作。

利用copyMemory方法，我們可以實現一個通用的物件拷貝方法，無需再對每一個物件都實現clone方法，當然這通用的方法只能做到物件淺拷貝。

二、非常規的物件例項化。

allocateInstance()方法提供了另一種建立例項的途徑。通常我們可以用new或者反射來例項化物件，使用allocateInstance()方法可以直接生成物件例項，且無需呼叫構造方法和其它初始化方法。

這在物件反序列化的時候會很有用，能夠重建和設定final欄位，而不需要呼叫構造方法。

三、操作類、物件、變數。

這部分包括了staticFieldOffset（靜態域偏移）、defineClass（定義類）、defineAnonymousClass（定義匿名類）、ensureClassInitialized（確保類初始化）、objectFieldOffset（物件域偏移）等方法。

通過這些方法我們可以獲取物件的指標，通過對指標進行偏移，我們不僅可以直接修改指標指向的資料（即使它們是私有的），甚至可以找到JVM已經認定為垃圾、可以進行回收的物件。

四、陣列操作。

這部分包括了arrayBaseOffset（獲取陣列第一個元素的偏移地址）、arrayIndexScale（獲取陣列中元素的增量地址）等方法。arrayBaseOffset與arrayIndexScale配合起來使用，就可以定位陣列中每個元素在記憶體中的位置。

由於Java的陣列最大值為Integer.MAX_VALUE，使用Unsafe類的記憶體分配方法可以實現超大陣列。實際上這樣的資料就可以認為是C陣列，因此需要注意在合適的時間釋放記憶體。

五、多執行緒同步。包括鎖機制、CAS操作等。

這部分包括了monitorEnter、tryMonitorEnter、monitorExit、compareAndSwapInt、compareAndSwap等方法。

其中monitorEnter、tryMonitorEnter、monitorExit已經被標記為deprecated，不建議使用。

Unsafe類的CAS操作可能是用的最多的，它為Java的鎖機制提供了一種新的解決辦法，比如AtomicInteger等類都是通過該方法來實現的。compareAndSwap方法是原子的，可以避免繁重的鎖機制，提高程式碼效率。這是一種樂觀鎖，通常認為在大部分情況下不出現競態條件，如果操作失敗，會不斷重試直到成功。

六、掛起與恢復。

這部分包括了park、unpark等方法。

將一個執行緒進行掛起是通過park方法實現的，呼叫 park後，執行緒將一直阻塞直到超時或者中斷等條件出現。unpark可以終止一個掛起的執行緒，使其恢復正常。整個併發框架中對執行緒的掛起操作被封裝在 LockSupport類中，LockSupport類中有各種版本pack方法，但最終都呼叫了Unsafe.park()方法。

七、記憶體屏障。

這部分包括了loadFence、storeFence、fullFence等方法。這是在Java 8新引入的，用於定義記憶體屏障，避免程式碼重排序。

loadFence() 表示該方法之前的所有load操作在記憶體屏障之前完成。同理storeFence()表示該方法之前的所有store操作在記憶體屏障之前完成。fullFence()表示該方法之前的所有load、store操作在記憶體屏障之前完成。

測試程式碼

import com.User;
import org.junit.Before;
import org.junit.Test;
import sun.misc.Unsafe;
 
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.UUID;
import java.util.concurrent.CountDownLatch;
 
class User {
 
  public static String USER_CLASS_NAME = "User.class";
  private int age;
  private String name;
 
  public int getAge() {
    return age;
  }
 
  public String getName() {
    return name;
  }
 
  public User(int age,String name) {
    this.age = age;
    this.name = name;
  }
 
  public void setAge(int age) {
    this.age = age;
  }
 
  public void setName(String name) {
    this.name = name;
  }
}
 
public class LockTests {
 
  Unsafe unSafe;
  User u = new User(17,"zhangsan");
 
  @Before
  public void before() throws Exception {
    Field theUnsafeField = Unsafe.class.getDeclaredField("theUnsafe");
    theUnsafeField.setAccessible(true);
    unSafe = (Unsafe) theUnsafeField.get(Unsafe.class);
  }
 
  @Test
  public void objectFieldOffset() throws Exception {
    // unSafe偏底層的一個Java工具類
    java.util.List users = new ArrayList();
    for (int i = 0; i < 10; i++) {
      Field ageField = User.class.getDeclaredField("age");
      User u = new User(18,"daxin");
      users.add(u);
      //使用記憶體獲取User age欄位在記憶體中的 offset
      // 是相對地址，不是一個絕對地址
      long ageOffset = unSafe.objectFieldOffset(ageField);
      // 每次都相同
      System.out.println("ageOffset = " + ageOffset);
    }
  }
 
  @Test
  public void compareAndSwapInt() throws Exception {
 
    // unSafe偏底層的一個Java工具類
    Field ageField = User.class.getDeclaredField("age");
 
    User u = new User(18,"daxin");
 
    //使用記憶體獲取User age欄位在記憶體中的 offset
    long ageOffset = unSafe.objectFieldOffset(ageField);
 
    // 修改之前的值
    System.out.println(u.getAge());
    // 進行CAS更新,由於設定18 因此CAS 會成功
    unSafe.compareAndSwapInt(u,ageOffset,18,20);
    System.out.println(u.getAge());
 
    // 由於age設定20 進行CAS失敗
    unSafe.compareAndSwapInt(u,22);
    System.out.println(u.getAge());
 
  }
 
  @Test
  public void ensureClassInitialized() {
    System.out.println("==== start ====");
    unSafe.ensureClassInitialized(ClassIsLoad.class);
    // 再次 確認不會報錯
    unSafe.ensureClassInitialized(ClassIsLoad.class);
  }
 
  /**
   * AQS 底層的Node連結串列就是基於這個工具實現的 。
   *
   * @throws Exception
   */
  @Test
  public void getValueByFieldOffset() throws Exception {
    for (int i = 0; i < 10; i++) {
      User u = new User(18,UUID.randomUUID().toString().substring(i,20));
      int age = unSafe.getInt(u,12L);
      System.out.println("age = " + age);
 
      // 獲取名字 field offset
      Field nameField = User.class.getDeclaredField("name");
      long nameOffset = unSafe.objectFieldOffset(nameField);
      System.out.println("nameOffset = " + nameOffset);
      String name = unSafe.getObject(u,nameOffset) + "";
      System.out.println("name = " + name);
    }
  }
 
  @Test
  public void pageSize() {
    System.out.println("unSafe.pageSize() = " + unSafe.pageSize());
  }
 
  /**
   * AtomicInteger 底層是基於getAndAddInt實現
   */
  @Test
  public void getAndAddInt() throws InterruptedException {
 
    User u = new User(17,"zhangsan");
    CountDownLatch downLatch = new CountDownLatch(10);
    System.out.println("u.getAge() = " + u.getAge());
    for (int i = 0; i < 10; i++) {
 
      new Thread(new Runnable() {
        @Override
        public void run() {
          downLatch.countDown();
          int val = unSafe.getAndAddInt(u,12L,1);
          System.out.println(Thread.currentThread().getName() + " val = " + val);
        }
      }).start();
 
    }
    Thread.sleep(5000);
    System.out.println("u.getAge() = " + u.getAge());
  }
 
  @Test
  public void getAndSetInt() throws InterruptedException {
    User u = new User(17,"zhangsan");
    CountDownLatch downLatch = new CountDownLatch(10);
    System.out.println("u.getAge() = " + u.getAge());
    for (int i = 0; i < 10; i++) {
 
      new Thread(new Runnable() {
        @Override
        public void run() {
          downLatch.countDown();
          int val = unSafe.getAndSetInt(u,10);
          System.out.println(Thread.currentThread().getName() + " val = " + val);
        }
      }).start();
 
    }
    Thread.sleep(5000);
    System.out.println("u.getAge() = " + u.getAge());
  }
 
 
  @Test
  public void getIntVolatile() {
 
    for (int i = 0; i < 10; i++) {
      u.setAge(i);
      /**
       * @param obj  the object containing the field to modify.
       * @param offset the offset of the integer field within <code>obj</code>.
       * @return
       */
      int age = unSafe.getIntVolatile(u,12L);
      System.out.println("age = " + age);
    }
  }
 
  // 系統負載取樣的介面
  @Test
  public void getLoadAverage() {
    double[] nums = new double[8];
    int val = unSafe.getLoadAverage(nums,8);
    System.out.println(val);
  }
 
 
  /**
   * //記憶體屏障，禁止load操作重排序。屏障前的load操作不能被重排序到屏障後，屏障後的load操作不能被重排序到屏障前
   * public native void loadFence();
   * <p>
   * <p>
   * 參見：https://tech.meituan.com/2019/02/14/talk-about-java-magic-class-unsafe.html
   */
 
  @Test
  public void loadFence() {
    //java.util.concurrent.locks.StampedLock.validate
    unSafe.loadFence();
  }
 
  /**
   * //記憶體屏障，禁止store操作重排序。屏障前的store操作不能被重排序到屏障後，屏障後的store操作不能被重排序到屏障前
   * public native void storeFence();
   * 參見：https://tech.meituan.com/2019/02/14/talk-about-java-magic-class-unsafe.html
   */
  @Test
  public void storeFence() {
  }
 
  /**
   * //記憶體屏障，禁止load、store操作重排序
   * public native void fullFence();
   * 參見：https://tech.meituan.com/2019/02/14/talk-about-java-magic-class-unsafe.html
   */
  @Test
  public void fullFence() {
  }
 
 
  @Test
  public void shouldBeInitialized() {
    boolean shouldBeInitialized = unSafe.shouldBeInitialized(String.class);
    System.out.println(shouldBeInitialized);
    shouldBeInitialized = unSafe.shouldBeInitialized(User.class);
    System.out.println(shouldBeInitialized);
  }
 
  /**
   * synchronized 的一種實現獲取鎖
   *
   * @throws InterruptedException
   */
  @Test
  public void monitorEnter() throws InterruptedException {
 
    unSafe.monitorEnter(u);
    new Thread(new Runnable() {
      @Override
      public void run() {
        synchronized (u) {
          System.out.println("==u lock got ==");
        }
      }
    }).start();
 
    Thread.sleep(2000);
    unSafe.monitorExit(u);
  }
 
  @Test
  public void compareAndSwap() {
//    unSafe.compareAndSwapInt(物件,物件中的欄位偏移,期望值,設定值)
//    unSafe.compareAndSwapLong(物件,設定值)
//    unSafe.compareAndSwapObject(物件,設定值)
  }
 
  @Test
  public void t() {
    // 方法簽名
    // public void copyMemory(Object srcBase,long srcOffset,Object destBase,long destOffset,long bytes)
    // unSafe.copyMemory();
  }
 
 
}
 
 
class ClassIsLoad {
 
  static {
    System.out.println("ClassIsLoad class Is Load !");
  }
}

以上就是本文的全部內容，希望對大家的學習有所幫助，也希望大家多多支援我們。

相關推薦

Java Unsafe類實現原理及測試程式碼

Unsafe類介紹 第一次看到這個類時被它的名字嚇到了，居然還有一個類自名Unsafe？讀完本文，大家也能發現Unsafe類確實有點不那麼安全，它能實現一些不那麼常見的功能。

Java方法過載實現原理及程式碼例項

方法的過載 過載就是在一個類中，有相同的函式名稱，但形參不同的函式 方法過載的規則：

java阻塞佇列實現原理及例項解析

這篇文章主要介紹了java阻塞佇列實現原理及例項解析,文中通過示例程式碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下

Java synchronize底層實現原理及優化

首先來說下synchronize和Lock的區別： 兩者都是鎖，用來控制併發衝突，區別在於Lock是個介面，提供的功能更加豐富，除了這個外，他們還有如下區別：

Java Lock介面實現原理及例項解析

1、概述 JUC中locks包下常用的類與介面圖如下： 圖中，Lock和ReadWriteLock是頂層鎖的介面，Lock代表實現類是ReentrantLock（可重入鎖），ReadWriteLock（讀寫鎖）的代表實現類是ReentrantReadWriteLock。

Java Builder模式實現原理及優缺點解析

Builder 模式中文叫作建造者模式，又叫生成器模式，它屬於物件建立型模式，是將一個複雜物件的構建與它的表示分離，使得同樣的構建過程可以建立不同的表示。建造者模式是一步一步建立一個複雜的物件，它允許使用者只

Java時區轉換及Date類實現原理解析

這篇文章主要介紹了Java時區轉換及Date類實現原理解析,文中通過示例程式碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下

Java三大器之攔截器(Interceptor)的實現原理及程式碼示例

1，攔截器的概念 java裡的攔截器是動態攔截Action呼叫的物件，它提供了一種機制可以使開發者在一個Action執行的前後執行一段程式碼，也可以在一個Action執行前阻止其執行，同時也提供了一種可以提取Action中可重

Java三大器之攔截器(Interceptor)的實現原理及程式碼示例(轉載)

來源：https://www.cnblogs.com/fps2tao/p/13494719.html     1，攔截器的概念    java裡的攔截器是動態攔截Action呼叫的物件，它提供了一種機制可以使開發者在一個Action執行的前後執行一段程式碼，也可以在一

Java繼承方法重寫實現原理及解析

這篇文章主要介紹了Java繼承方法重寫實現原理及解析,文中通過示例程式碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下

Java執行緒併發工具類CountDownLatch原理及用法

一、CountDownLatch 【1】CountDownLatch是什麼？ CountDownLatch，英文翻譯為倒計時鎖存器，是一個同步輔助類，在完成一組正在其他執行緒中執行的操作之前，它允許一個或

Qt 實現畫線筆鋒效果詳細原理及示例程式碼

前言 之前寫過一篇文章介紹Qt中繪製平滑曲線的兩種方式，文章在這裡。這篇文章詳細介紹了繪製的原理和實現方式，那麼，如果要在此曲線上實現筆鋒效果怎麼做呢？

Java訪問修飾符原理及程式碼解析

一、概述 訪問等級比較：public > protected > default > private 無論是方法還是成員變數，這四種訪問許可權修飾符作用都一樣

Java Unsafe類 CAS簡單使用實現自旋鎖

自己實現了一個類似AtomicInteger的原子類功能，反覆比較並交換，主要用到 反射獲取Unsafe及物件的靜態成員變數

Android浮動視窗實現原理及程式碼例項

1.浮動視窗的實現原理 看到上圖的那個小Android圖示了吧，它不會被其他組建遮擋，也可以響應使用者的點選和拖動事件，它的顯示和消失由WindowManager直接管理，它就是Android浮動視窗。Android浮動視窗的實現主要是

Java CAS基本實現原理程式碼例項解析

一、前言 瞭解CAS,首先要清楚JUC,那麼什麼是JUC呢？JUC就是java.util.concurrent包的簡稱。它有核心就是CAS與AQS。CAS是java.util.concurrent.atomic包的基礎，如AtomicInteger、AtomicBoolean、AtomicLong等等類都

壓力測試工具Apache Bench實現原理及用法解析

1：吞吐率（Requests per second） 伺服器併發處理能力的量化描述，單位是reqs/s，指的是某個併發使用者數下單位時間內處理的請求數。某個併發使用者數下單位時間內能處理的最大請求數，稱之為最大吞吐率。

常見排序演算法原理及JS程式碼實現

目錄陣列 sort() 方法氣泡排序選擇排序插入排序希爾排序歸併排序堆排序快速排序

Springboot Session共享實現原理及程式碼例項

在傳統的單服務架構中，一般來說，只有一個伺服器，那麼不存在 Session 共享問題，但是在分散式/叢集專案中，Session 共享則是一個必須面對的問題，先看一個簡單的架構圖：

MyBatis快取實現原理及程式碼例項解析

一、一級快取（本地快取） 　　sqlSession級別的快取。一級快取是一直開啟的；SqlSession級別的一個Map與資料庫同一次會話期間查詢到的資料會放在本地快取中。以後如果需要獲取相同的資料，直接從快取中拿，沒必要再