摘要：是一款用來分析應(yīng)用的圖形工具，能夠?qū)?yīng)用程序做性能分析和調(diào)優(yōu)。計算特征點特征點根據(jù)特征點，計算對應(yīng)的如果只有一個元素，說明沒有特征值優(yōu)化二背景接下來解決第二個函數(shù)。成果經(jīng)過這兩個主要的優(yōu)化，就解決了代碼中的性能問題，成果如下圖所示

本文作者：CODING 工程師 Tan He

項目中的某一個接口，在某一場景下（數(shù)據(jù)量大），性能讓人難以忍受。

那么如何有什么工具可以定位引發(fā)性能問題的代碼呢？其實有很多，這里我們使用 Visual VM。

Visual VM 是一款用來分析 Java 應(yīng)用的圖形工具，能夠?qū)?Java 應(yīng)用程序做性能分析和調(diào)優(yōu)。如果你使用的 java 7 或者 java 8，那么可以直接在 JDK 的 bin 目錄找到該工具，名稱為 jvisualvm。當(dāng)然也可以在官網(wǎng)上自行下載。

使用 Visual VM 分析某個接口的性能的方法如下：

結(jié)果顯示如下:

通過上圖，我們可以看到比較耗時的方法為 resolveBytePosition 和 rest，getFile 和 currentUser 是網(wǎng)絡(luò)請求，暫不考慮。

首先拿 resolveBytePosition 方法開刀。為了能更容易的解釋 resolveBytePosition 的用途，舉個例子。

給定一個字符串 chars 與該字符串的 UTF-8 二進(jìn)制數(shù)組(空格用來隔開字符數(shù)據(jù)，實際并不存在):

chars = "just一個test";
bytes = "6A 75 73 74 E4B880 E4B8AA 74 65 73 74";

resolveBytePosition 用來解決給定一個 bytes 的偏移 bytePos 計算 chars 中的偏移 charPos 的問題。比如:

bytePos = 0 (6A) 對應(yīng) charPos = 0 (j)
bytePos = 1 (75) 對應(yīng) charPos = 1 (u)

如果使用 array[start:] 表示從下標(biāo) start 開始截取數(shù)組元素至末尾組成的新數(shù)組，那么則有：

bytes[bytePos:] = chars[charPos:]

舉例:

bytes[0:] = chars[0:]
bytes[1:] = chars[1:]
bytes[10:] = chars[6:]

明白了 resolveBytePosition 的作用，看一下它的實現(xiàn)

public int resolveBytePosition(byte[] bytes, int bytePos) {
    return new String(slice(bytes, 0, bytePos)).length();
}

該解法簡單粗暴，能夠準(zhǔn)確的計算出結(jié)果，但是缺點顯而易見，頻繁的構(gòu)建字符串，對性能造成了極大的影響。通過 Visual VM 可以證實我們的推論，通過點擊快照，查看更詳細(xì)的方法調(diào)用耗時。

為了更方便的剖析問題，我們繪制如下表格，用來展示每一個字符的 UTF-8 以及 Unicode 的二進(jìn)制數(shù)據(jù)：

接著我們將字節(jié)數(shù)據(jù)轉(zhuǎn)換為字節(jié)長度：

Java中的使用 char 來表示Unicode，char 的長度為 2 個字節(jié)，因此一個 char 足以表示示例中的任何一個字符。

我們使用一個單元格表示一個byte（UTF-8）或一個char（Unicode），并對單元格編號，得到下表：

可以得出下面對應(yīng)關(guān)系

bytes[0:] = chars[0:]
bytes[1:] = chars[1:]
bytes[2:] = chars[2:]
bytes[3:] = chars[3:]
bytes[4:] = chars[4:]
bytes[7:] = chars[5:]
bytes[10:] = chars[6:]
... ...

進(jìn)行到這一步，高效的算法已經(jīng)呼之欲出了。算法如下：

把字符 UTF-8 數(shù)據(jù)的二進(jìn)制長度不為 1 的稱為特征點。除特征點外，每個字符都是一個字節(jié)長度。記下所有特征點的對應(yīng)關(guān)系，對于給定的 bytePos，都可以根據(jù)公式計算得到 charPos。

公式為:

charPos = bytePos - preBytePos + preCharPos

舉例：

則本實例中有兩個特征點 一、個，記作：

bytes[6:] = chars[4:]
bytes[9:] = chars[5:]

如果給定 bytePos 10, 首先找到前一個特征點的對應(yīng)關(guān)系 9（preBytePos） -> 5（preCharPos), 根據(jù)公式得出 (10 - 9) + 5 = 6。

該算法還有一個比較關(guān)鍵的問題要解決，即高效的計算一個 char 的字節(jié)長度。計算 char 的字節(jié)長度的算法參考了 StackOverflow。

// 計算特征點
private int[][] calcSpecialPos(String str) {
    ArrayList specialPos = new ArrayList<>()

    specialPos.add(new int[] {0, 0});

    int lastCharPost = 0;
    int lastBytePos = 0;

    Charset utf8 = Charset.forName("UTF-8");
    CharsetEncoder encoder = utf8.newEncoder();
    CharBuffer input = CharBuffer.wrap(str.toCharArray());
    ByteBuffer output = ByteBuffer.allocate(10);

    int limit = input.limit();
    while(input.position() < limit) {
        output.clear();
        input.mark();
        input.limit(Math.min(input.position() + 2, input.capacity()));
        if (Character.isHighSurrogate(input.get()) && !Character.isLowSurrogate(input.get())) {
            //Malformed surrogate pair
            lastCharPost++;
        }
        input.limit(input.position());
        input.reset();
        encoder.encode(input, output, false);

        int encodedLen = output.position();
        lastCharPost++;
        lastBytePos += encodedLen;

        if (encodedLen != 1) { // 特征點
            specialPos.add(new int[]{lastBytePos, lastCharPost});
        }
    }


    return toArray(specialPos);
}

// 根據(jù)特征點，計算 bytePos 對應(yīng)的 charPos
private int calcPos(int[][] specialPos, int bytePos) {
    // 如果只有一個元素 {0, 0)，說明沒有特征值
    if (specialPos.length == 1) return bytePos;

    int pos = Arrays.binarySearch(specialPos,
            new int[] {bytePos, 0},
            (int[] a, int[] b) -> Integer.compare(a[0], b[0]));

    if (pos >= 0) {
        return specialPos[pos][1];
    } else {
        // if binary search not fonund, will return (-(insertion point) - 1),
        // so here -2 is mean -1 to get insertpoint and then -1 to get previous specialPos
        int[] preSpecialPos = specialPos[-pos-2];
        return bytePos - preSpecialPos[0] + preSpecialPos[1];
    }
}

接下來解決第二個函數(shù) rest。該函數(shù)的功能是得到 JsonArray（gson） 的除第一個元素外的所有元素。

由于 rest 是在一個遞歸函數(shù)中被調(diào)用且遞歸棧很深，因此如果 rest 實現(xiàn)的不夠高效，其影響會被成倍放大。

private JsonArray rest(JsonArray arr) {
    JsonArray result = new JsonArray();
    if (arr.size() > 1) {
        for (int i = 1; i < arr.size(); i++) {
            result.add(arr.get(i));
        }
    }
    return result;
}

通過調(diào)試發(fā)現(xiàn) JsonArray 中存儲了相當(dāng)大的數(shù)據(jù)，對于頻繁調(diào)用的場景，每次都對其重新構(gòu)建明顯不是一個明智的選擇。
通過查看返回的 JsonArray 使用情況，我們得到了另一條線索：僅僅使用里面的數(shù)據(jù)，而不涉及修改。

考慮到 JsonArray 被實現(xiàn)成 final，最后方案確定為實現(xiàn)一個針對 rest 這種需求定制的代理類。

代理類 JsonArrayWrapper 分別對 first、rest、foreach 等功能進(jìn)行了實現(xiàn)。

class JsonArrayWrapper implements Iterable {
    private JsonArray jsonArray;

    private int mark;

    public JsonArrayWrapper() {
        this.jsonArray = new JsonArray();
        this.mark = 0;
    }

    public JsonArrayWrapper(JsonArray jsonArray) {
        this.jsonArray= jsonArray;
        this.mark = 0;
    }

    public JsonArrayWrapper(JsonArray jsonArray, int mark) {
        this.jsonArray = jsonArray;
        this.mark = mark;
    }

    public JsonObject first() {
        return jsonArray.get(mark).getAsJsonObject();
    }

    public JsonArrayWrapper rest() {
        return new JsonArrayWrapper(jsonArray, mark+1);
    }

    public int size() {
        return jsonArray.size() - mark;
    }

    public JsonElement get(int n) {
        return jsonArray.get(mark + n);
    }

    public void add(JsonElement jsonElement) {
        jsonArray.add(jsonElement);
    }

    public void addAll(JsonArrayWrapper jsonArrayWrapper) {
        jsonArrayWrapper.forEach(this.jsonArray::add);
    }

    @Override
    public Iterator iterator() {
        JsonArray jsonarray = new JsonArray();
        this.forEach(e -> jsonarray.add(e));
        return jsonarray.iterator();
    }

    @Override
    public void forEach(Consumer action) {
        for (int i=mark; i
4 成果
經(jīng)過這兩個主要的優(yōu)化，就解決了代碼中的性能問題，成果如下圖所示：