一、相關知識JDK String的實作

字串在JDK 8及JDK 9之后的實作有很大不同的，JDK 8中，String的結構是這樣的：

1.1 String JDK 8的實作

class String {
    char[] value;

    // 建構式會拷貝
    public String(char value[]) {
        this.value = https://www.cnblogs.com/88223100/archive/2023/02/11/Arrays.copyOf(value, value.length);
    }

    // 無拷貝建構式
    String(char[] value, boolean share) {
        // assert share :"unshared not supported";
        this.value = https://www.cnblogs.com/88223100/archive/2023/02/11/value;
    }
}

1.2 String JDK 9及之后版本的實作

class String {
    static final byte LATIN1 = 0;
    static final byte UTF16  = 1;
    
    byte code;
    byte[] value;

    // 無拷貝建構式
    String(byte[] value, byte coder) {
        this.value = https://www.cnblogs.com/88223100/archive/2023/02/11/value;
        this.coder = coder;
    }
}

JDK9之后，通過byte[]來保存value，通過code欄位區分是LATIN1或者UTF16，大多數的字串都是LATIN1，針對這種情況，我們構造字串或者對字串進行編碼為二進制時，針對性做ZeroCopy的實作，可以獲得極致的性能，

二、相關知識Unsafe

JDK 8之后提供sun.Unsafe可以做一些原生的操作，性能更好，不安全，錯誤的呼叫會導致JVM Crash，如果用對了，能提升性能，Unsafe能幫你繞過任何限制，


public class UnsafeUtils {
    public static final Unsafe UNSAFE;
    
    static {
        Unsafe unsafe = null;
        try {
            Field theUnsafeField = Unsafe.class.getDeclaredField("theUnsafe");
            theUnsafeField.setAccessible(true);
            unsafe = (Unsafe) theUnsafeField.get(null);
        } catch (Throwable ignored) {
            // ignored
        }
        UNSAFE = unsafe;
    }
}

三、相關知識Trusted MethodHandles.Lookup

JDK 8開始支持Lambda，為了方便將一個Method映射為一個Lambda Function，避免反射開銷，java.invoke.LambdaMetafactory可以實作這一功能，但這個也受限于可見性的限制，也就是說不能呼叫私有方法，有一個技巧，結合Unsafe，可以在不同版本的JDK都能構造一個Trusted MethodHandles.Lookup來繞開可見性的限制，呼叫任何JDK內部方法，如下：


import static com.alibaba.fastjson2.util.UnsafeUtils.UNSAFE;

static final MethodHandles.Lookup IMPL_LOOKUP;

static {
    Class lookupClass = MethodHandles.Lookup.class;
    Field implLookup = lookupClass.getDeclaredField("IMPL_LOOKUP");
    long fieldOffset = UNSAFE.staticFieldOffset(implLookup);
    IMPL_LOOKUP = (MethodHandles.Lookup) UNSAFE.getObject(lookupClass, fieldOffset);
}

static MethodHandles.Lookup trustedLookup(Class objectClass) throws Exception {
    return IMPL_LOOKUP.in(objectClass);
}

注意：在IBM OpenJ9 JDK 8/11版本上面的實作受到可見性限制，需要欄位外處理，參考FASTJSON2 JDKUtils#trustedLookup的代碼：

https://github.com/alibaba/fastjson2/blob/fastcode_demo_20221218/core/src/main/java/com/alibaba/fastjson2/util/JDKUtils.java#L254

四、零拷貝構造String物件

快速構造字串的關鍵是要做減少拷貝，甚至零拷貝，在JDK 8、JDK 9~15、JDK 16及之后的版本的實作都不一樣，

4.1 JDK 8零拷貝構造String物件的實作

在JDK8中，實作零拷貝構造String物件，需要呼叫其建構式String(char[], boolean)，比如：


BiFunction<char[], Boolean, String>  stringCreatorJDK8
    = (char[] value, boolean share) -> new String(chars, boolean);

由于String(char[], boolean)方法不是public的，上面的代碼會報錯，要通過反射構造一個TRUSTED的MethodHandles.Lookup，然呼叫String的內部方法，映射成一個BiFunction<char[], Boolean, String>，代碼如下：

import com.alibaba.fastjson2.util.JDKUtils;

import java.util.function.BiFunction;
import java.lang.invoke.MethodHandles;
import static java.lang.invoke.MethodType.methodType;

MethodHandles.Lookup caller = JDKUtils.trustedLookup(String.class);

MethodHandle handle = caller.findConstructor(
        String.class, 
        methodType(void.class, char[].class, boolean.class)
);

CallSite callSite = LambdaMetafactory.metafactory(
        caller,
        "apply",
        methodType(BiFunction.class),
        methodType(Object.class, Object.class, Object.class),
        handle,
        methodType(String.class, char[].class, boolean.class)
);
BiFunction<char[], Boolean, String>  STRING_CREATOR_JDK8 
    = (BiFunction<char[], Boolean, String>) 
      callSite.getTarget().invokeExact();

4.2 JDK9及之后版本實作零拷貝構造String物件的實作

在JDK 9~JDK 15中，我們要構造一個這樣的Function用于零拷貝構造String物件：


BiFunction<byte[], Byte, String> STRING_CREATOR_JDK11 
    = (byte[] value, byte coder) -> new String(value, coder);

同樣，JDK 9中的String(byte[], byte)方法不是public，無法直接呼叫，上面的代碼會報錯，要構造一個TRUSTED MethodHandles.Lookup方法呼叫String內部方法，如下：


import com.alibaba.fastjson2.util.JDKUtils;
import static java.lang.invoke.MethodType.methodType;

MethodHandles.Lookup caller = JDKUtils.trustedLookup(String.class);
MethodHandle handle = caller.findConstructor(
        String.class, 
        methodType(void.class, byte[].class, byte.class)
);
CallSite callSite = LambdaMetafactory.metafactory(
        caller,
        "apply",
        methodType(BiFunction.class),
        methodType(Object.class, Object.class, Object.class),
        handle,
        methodType(String.class, byte[].class, Byte.class)
);
BiFunction<byte[], Byte, String> STRING_CREATOR_JDK11 
    = (BiFunction<byte[], Byte, String>) 
      callSite.getTarget().invokeExact();

注意：當用戶配置JVM引數-XX:-CompactStrings時，上述方法無效，

4.3 快速構造String物件應用舉例

stiatic BiFunction<char[], Boolean, String>  STRING_CREATOR_JDK8 = ...
static BiFunction<byte[], Byte, String> STRING_CREATOR_JDK11 = ... 

static String formatYYYYMMDD(LocalDate date) {
    int year = date.getYear();
    int month = date.getMonthValue();
    int dayOfMonth = date.getDayOfMonth();

    int y0 = year / 1000 + '0';
    int y1 = (year / 100) % 10 + '0';
    int y2 = (year / 10) % 10 + '0';
    int y3 = year % 10 + '0';
    int m0 = month / 10 + '0';
    int m1 = month % 10 + '0';
    int d0 = dayOfMonth / 10 + '0';
    int d1 = dayOfMonth % 10 + '0';

    String str;
    if (STRING_CREATOR_JDK11 != null) {
        byte[] bytes = new byte[10];
        bytes[0] = (byte) y0;
        bytes[1] = (byte) y1;
        bytes[2] = (byte) y2;
        bytes[3] = (byte) y3;
        bytes[4] = '-';
        bytes[5] = (byte) m0;
        bytes[6] = (byte) m1;
        bytes[7] = '-';
        bytes[8] = (byte) d0;
        bytes[9] = (byte) d1;
        str = STRING_CREATOR_JDK11.apply(bytes, JDKUtils.LATIN1);
    } else {
        char[] chars = new char[10];
        chars[0] = (char) y1;
        chars[1] = (char) y2;
        chars[2] = (char) y3;
        chars[3] = (char) y4;
        chars[4] = '-';
        chars[5] = (char) m0;
        chars[6] = (char) m1;
        chars[7] = '-';
        chars[8] = (char) d0;
        chars[9] = (char) d1;

        if (STRING_CREATOR_JDK8 != null) {
            str = STRING_CREATOR_JDK8.apply(chars, Boolean.TRUE);
        } else {
            str = new String(chars);
        }
    }
    return str;
}

上面的例子中，根據JDK版本，在JDK 8中直接創建char[]，JDK 9中直接創建byte[]，然后通過零拷貝的方式構造字串物件，這樣就實作了快速格式化LocalDate到String，這樣的實作遠比使用SimpleDateFormat/java.time.DateTimeFormat等實作要快得多，

五、直接訪問String物件內部成員

5.1 JDK 8快速訪問value

static final Field FIELD_STRING_VALUE;
static final long FIELD_STRING_VALUE_OFFSET;

static {
    Field field = null;
    long fieldOffset = -1;
    try {
        field = String.class.getDeclaredField("value");
        fieldOffset = UnsafeUtils.objectFieldOffset(field);
    } catch (Exception ignored) {
        FIELD_STRING_ERROR = true;
    }

    FIELD_STRING_VALUE = https://www.cnblogs.com/88223100/archive/2023/02/11/field;
    FIELD_STRING_VALUE_OFFSET = fieldOffset;
}

public static char[] getCharArray(String str) {
    if (!FIELD_STRING_ERROR) {
        try {
            return (char[]) UnsafeUtils.UNSAFE.getObject(
                str, 
                FIELD_STRING_VALUE_OFFSET
            );
        } catch (Exception ignored) {
            FIELD_STRING_ERROR = true;
        }
    }

    return str.toCharArray();
}

5.2 JDK 9及之后版本直接訪問coder & value

我們需要構造如下的函式：


ToIntFunction<String> stringCoder = (String str) -> str.coder();
Function<String, byte[]> stringValue = https://www.cnblogs.com/88223100/archive/2023/02/11/(String str) -> str.value();

但由于String.coder和value方法不是public可見的，和上面的4.2類似，要通過TRUSTED MethodHandles.Lookup構造，如下：

import com.alibaba.fastjson2.util.JDKUtils;
import static java.lang.invoke.MethodType.methodType;

MethodHandles.Lookup lookup = JDKUtils.trustedLookup(String.class);
MethodHandle coder = lookup.findSpecial(
        String.class,
        "coder",
        methodType(byte.class),
        String.class
);
CallSite applyAsInt = LambdaMetafactory.metafactory(
        lookup,
        "applyAsInt",
        methodType(ToIntFunction.class),
        methodType(int.class, Object.class),
        coder,
        MethodType.methodType(byte.class, String.class)
);
ToIntFunction<String> STRING_CODER 
    = (ToIntFunction<String>) applyAsInt.getTarget().invokeExact();

MethodHandle value = https://www.cnblogs.com/88223100/archive/2023/02/11/lookup.findSpecial(
        String.class,"value",
         methodType(byte[].class),
        String.class
);
CallSite apply = LambdaMetafactory.metafactory(
        lookup,
        "apply",
        methodType(Function.class),
        methodType(Object.class, Object.class),
        value,
        methodType(byte[].class, String.class)
);
Function<String, byte[]> STRING_VALUE 
     = https://www.cnblogs.com/88223100/archive/2023/02/11/(Function) apply.getTarget().invokeExact();

5.3 直接訪問舉例

static Byte LATIN1 = 0;
static ToIntFunction<String> STRING_CODER = ...
static Function<String, byte[]> STRING_VALUE ...

byte[] buf = ...;
int off;

void writeString(string str) {
    if (STRING_CODER != null && STRING_VALUE != null) {
        // improved for JDK 9 LATIN1
        int coder = stringCoder.apply(str);
        if (coder == LATIN1) {
            // str.getBytes(0, str.length, buf, off);
            byte[] value = https://www.cnblogs.com/88223100/archive/2023/02/11/STRING_VALUE.apply(str);
            System.arrayCopy(value, 0, buf, off, value.length);
            return;
        }
    }
    // normal logic
}

5.4 巧用String.getBytes方法

String有一個Deprecated的getBytes方法，當有非LATIN字符時，結果不對，但當在coder為LATIN1時，可用于直接拷貝其中value，


class String {
    @Deprecated
    public void getBytes(int srcBegin, int srcEnd, byte dst[], int dstBegin) {
        int j = dstBegin;
        int n = srcEnd;
        int i = srcBegin;
        char[] val = value;   /* avoid getfield opcode */

        while (i < n) {
            dst[j++] = (byte)val[i++];
        }
    }
}


static Byte LATIN1 = 0;
static ToIntFunction<String> STRING_CODER = ...

byte[] buf = ...;
int off;

void writeString(string str) {
    if (STRING_CODER != null) {
        // improved for JDK 9 LATIN1
        int coder = STRING_CODER.apply(str);
        if (coder == LATIN1) {
            str.getBytes(0, str.length, buf, off);
            return;
        }
    }
    // normal logic
}

參考實作：

FASTJSON2專案使用了上面的技巧，其中JDKUtils和UnsafeUtils有上面技巧的實作：

JDKUtils：https://github.com/alibaba/fastjson2/blob/fastcode_demo_20221218/core/src/main/java/com/alibaba/fastjson2/util/JDKUtils.java
UnsafeUtils：https://github.com/alibaba/fastjson2/blob/fastcode_demo_20221218/core/src/main/java/com/alibaba/fastjson2/util/UnsafeUtils.java

注意事項：

上面的技巧不建議新手使用，需要先清楚原理，才可使用，

作者| 溫紹錦(高鐵)

本文來自博客園，作者：古道輕風，轉載請注明原文鏈接：https://www.cnblogs.com/88223100/p/Tips-for-quickly-constructing-String-objects-and-accessing-their-internal-members.html

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/543602.html

標籤：其他

上一篇：類和類的定義

下一篇：chatGPT接入個人微信(國內可用)

干貨總結｜快速構造String物件及訪問其內部成員的技巧

參考實作：

注意事項：