• 用「Lambda 生成函數(shù)映射」代替「高頻的反射操作」

• 對 String 做零拷貝優(yōu)化

• 常見類型解析優(yōu)化

public class Bean {    int id;    public int getId() {        return id;    }}
Method methodGetId = Bean.class.getMethod("getId");Bean bean = createInstance();int value = (Integer) methodGetId.invoke(bean);

上面的反射執(zhí)行代碼可以被改寫成這樣：

// 將getId()映射為function函數(shù)java.util.function.ToIntFunction<Bean> function = Bean::getId; int i = function.applyAsInt(bean);

fastjson2 中的具體實現(xiàn)的要復(fù)雜一點，但本質(zhì)上跟上面一樣，其本質(zhì)也是生成了一個 function。

//functionjava.util.function.ToIntFunction<Bean> function = LambdaMetafactory.metafactory(        lookup,        "applyAsInt",        methodHanlder,        methodType(ToIntFunction.class),        lookup.findVirtual(int.class, "getId", methodType(int.class)),        methodType(int.class));int i = function.applyAsInt(bean);

Method invoke elapsed: 25msBean::getId elapsed: 1ms

處理速度相差居然達(dá)到 25 倍，使用 Java8 Lambda 為什么能提升這多呢？

public Object invoke(Object obj, Object... args) throws IllegalAccessException, IllegalArgumentException,InvocationTargetException{    if (!override) {        if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {            Class<?> caller = Reflection.getCallerClass();            checkAccess(caller, clazz, obj, modifiers);        }    }    MethodAccessor ma = methodAccessor;// read volatile    if (ma == null) ma = acquireMethodAccessor();    return ma.invoke(obj, args);}

可見，經(jīng)過簡單的檢查后，調(diào)用的是MethodAccessor.invoke()，這部分的實際實現(xiàn)：

public Object invoke(Object var1, Object[] var2) throws IllegalArgumentException, InvocationTargetException {    if (++this.numInvocations > ReflectionFactory.inflationThreshold() && !ReflectUtil.isVMAnonymousClass(this.method.getDeclaringClass())) {        MethodAccessorImpl var3 = (MethodAccessorImpl)(new MethodAccessorGenerator()).generateMethod(this.method.getDeclaringClass(), this.method.getName(), this.method.getParameterTypes(), this.method.getReturnType(), this.method.getExceptionTypes(), this.method.getModifiers());        this.parent.setDelegate(var3);    }    return invoke0(this.method, var1, var2);}
private static native Object invoke0(Method var0, Object var1, Object[] var2);

可見，最終調(diào)用的是 native 本地方法（本地方法棧）的 invoke0()，這部分的實現(xiàn)：

JNIEXPORT jobject JNICALL Java_sun_reflect_NativeMethodAccessorImpl_invoke0(JNIEnv *env, jclass unused, jobject m, jobject obj, jobjectArray args){    return JVM_InvokeMethod(env, m, obj, args);}

可見，調(diào)用的是 jvm.h 模塊的 JVM_InvokeMethod 方法，這部分的實現(xiàn)：

JNIEXPORT jobject JNICALL Java_sun_reflect_NativeMethodAccessorImpl_invoke0(JNIEnv *env, jclass unused, jobject m, jobject obj, jobjectArray args){    return JVM_InvokeMethod(env, m, obj, args);}

具體來講，Bean::getId 這種 Lambda 寫法進(jìn)過編譯后，會通過 java.lang.invoke.LambdaMetafactory 

調(diào)用到

java.lang.invoke.InnerClassLambdaMetafactory#spinInnerClass

static BiFunction<char[], Boolean, String>  STRING_CREATOR_JDK8;static {    //為上述String的0拷貝構(gòu)造方法創(chuàng)建一個映射函數(shù)    CallSite callSite = LambdaMetafactory.metafactory(caller, "apply", methodType(BiFunction.class), methodType(Object.class, Object.class, Object.class), handle, methodType(String.class, char[].class, boolean.class));    STRING_CREATOR_JDK8 = (BiFunction<char[], Boolean, String>) callSite.getTarget().invokeExact();}
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';
    //char array    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;
    //執(zhí)行「lambda函數(shù)映射」構(gòu)造String    String str = STRING_CREATOR_JDK8.apply(chars, Boolean.TRUE);    return str;}

在 JDK8 的實現(xiàn)中，先拼接好格式中每一個 char 字符，然后通過零拷貝的方式構(gòu)造字符串對象，這樣就實現(xiàn)了快速格式化 LocalDate 到 String，這樣的實現(xiàn)遠(yuǎn)比使用 SimpleDateFormat 之類要快。這種實例化 String 的方式在fatsjson2 中的 JSONReader、JSONWritter 隨處可見。

static final ThreadLocal<SimpleDateFormat> formatThreadLocal = ThreadLocal.withInitial(        () -> new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
// get format from ThreadLocalSimpleDateFormat format = formatThreadLocal.get();format.parse(str);

static final DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
// use formatter parse DateLocalDateTime ldt = LocalDateTime.parse(str, formatter);ZoneOffset offset = DEFAULT_ZONE_ID.getRules().getOffset(ldt);long millis = ldt.toInstant(offset).toEpochMilli();Date date = new Date(millis);

這種方法比使用 SimpleDateFormat 組合 ThreadLocal 代碼更簡潔，速度也大約要快 50%。

public static Date parseYYYYMMDDHHMMSS19(String str) {    char y0 = str.charAt(0);    char y1 = str.charAt(1);    char y2 = str.charAt(2);    char y3 = str.charAt(3);    char m0 = str.charAt(4);    char m1 = str.charAt(5);    ...    char s1 = str.charAt(18);
    int year = (y0 - '0') * 1000 + (y1 - '0') * 100 + (y2 - '0') * 10 + (y3 - '0');    int month = (m0 - '0') * 10 + (m1 - '0');    int dom = (d0 - '0') * 10 + (d1 - '0');    int hour = (h0 - '0') * 10 + (h1 - '0');    int minute = (i0 - '0') * 10 + (i1 - '0');    int second = (s0 - '0') * 10 + (s1 - '0');
    //換算成毫秒    long millis;    if (year >= 1992 && (DEFAULT_ZONE_ID == SHANGHAI_ZONE_ID || DEFAULT_ZONE_ID.getRules() == IOUtils.SHANGHAI_ZONE_RULES)) {
        final int DAYS_PER_CYCLE = 146097;        final long DAYS_0000_TO_1970 = (DAYS_PER_CYCLE * 5L) - (30L * 365L + 7L);
        long y = year;        long m = month;
        long epochDay;        {            long total = 0;            total += 365 * y;            total += (y + 3) / 4 - (y + 99) / 100 + (y + 399) / 400;            total += ((367 * m - 362) / 12);            total += dom - 1;            if (m > 2) {                total--;                boolean leapYear = (year & 3) == 0 && ((year % 100) != 0 || (year % 400) == 0);                if (!leapYear) {                    total--;                }            }            epochDay = total - DAYS_0000_TO_1970;        }        long seconds = epochDay * 86400                + hour * 3600                + minute * 60                + second                - SHANGHAI_ZONE_OFFSET_TOTAL_SECONDS;
        millis = seconds * 1000L;    } else {        LocalDate localDate = LocalDate.of(year, month, dom);        LocalTime localTime = LocalTime.of(hour, minute, second, 0);        LocalDateTime ldt = LocalDateTime.of(localDate, localTime);        ZoneOffset offset = DEFAULT_ZONE_ID.getRules().getOffset(ldt);        millis = ldt.toEpochSecond(offset) * 1000;    }
    return new Date(millis);}

核心邏輯就是根據(jù)位數(shù)，直接開始計算給定的時間字符串，相對于參照的原點時間（1970-1-1 0點）過去了多少毫秒，這個優(yōu)化，避免了parse Number的開銷，精簡了大量 Partten 的處理，處理流程非常高效。

JMH測試顯示：方法 3 的耗時遠(yuǎn)低于其他方式，方法 3 這種針對性的類型解析優(yōu)化可以使用在重度使用日期解析的優(yōu)化場景，比如數(shù)據(jù)批量導(dǎo)入解析日期，大數(shù)據(jù)場景的 UDF 日期解析等。

[1]https://github.com/alibaba/fastjson2

[2]https://github.com/alibaba/fastjson2/wiki/fastjson_benchmark

[3]https://so.csdn.net/so/search?q=零拷貝&spm=1001.2101.3001.7020

[4]https://www.joda.org/joda-time/

[5]https://github.com/alibaba/fastjson2/blob/main/benchmark/src/main/java/com/alibaba/fastjson2/benchmark/DateParse.java