基於: macOs:10.13/AS:3.3.2/Android build-tools:28.0.0/jdk: 1.8
1. 緣由
這兩天在看 smali, 偶然看到 log 語句中的 String 拼接被優化為了 StringBuilder, 程式碼如下;
// MainActivity.java
public class MainActivity extends AppCompatActivity implements View.OnClickListener {
private static final String TAG = "MainActivity";
private void methodBoolean(boolean showLog) {
Log.d(TAG, "methodBoolean: " + showLog);
}
}
複製程式碼# 對應的 smali 程式碼
.method private methodBoolean(Z)V
.locals 3
.param p1, "showLog" # Z
.line 51
const-string v0, "MainActivity" # 定義 TAG 變數值
new-instance v1, Ljava/lang/StringBuilder; # 建立了一個 StringBuilder
invoke-direct {v1}, Ljava/lang/StringBuilder;-><init>()V
# 定義 Log msg引數中第一部分字串字面量值
const-string v2, "methodBoolean: "
# 拼接並輸出 String 存入 v1 暫存器中
invoke-virtual {v1, v2}, Ljava/lang/StringBuilder;->append(Ljava/lang/String;)Ljava/lang/StringBuilder;
invoke-virtual {v1, p1}, Ljava/lang/StringBuilder;->append(Z)Ljava/lang/StringBuilder;
invoke-virtual {v1}, Ljava/lang/StringBuilder;->toString()Ljava/lang/String;
move-result-object v1
# 呼叫 Log 方法列印日誌
invoke-static {v0, v1}, Landroid/util/Log;->d(Ljava/lang/String;Ljava/lang/String;)I
.line 52
return-void
.end method
複製程式碼想起以前根深蒂固的 "大量字串拼接時 StringBuilder 比 String 效能更好" 的說法, 頓時好奇是否真是那樣, 是否所有場景都那樣, 所以想探究下, 簡單起見, 原始碼用 Java 而非 Kotlin 編寫;
2. 測試
既然底層會優化為 StringBuilder 那拼接還會有效率差距嗎? 測試下
public class MainActivity extends AppCompatActivity implements View.OnClickListener {
/**
* String迴圈拼接測試
*
* @param loop 迴圈次數
* @param base 拼接字串
* @return 耗時, 單位: ms
*/
private long methodForStr(int loop, String base) {
long startTs = System.currentTimeMillis();
String result = "";
for (int i = 0; i < loop; i++) {
result += base;
}
return System.currentTimeMillis() - startTs;
}
/**
* StringBuilder迴圈拼接測試
*/
@Keep
private long methodForSb(int loop, String base) {
long startTs = System.currentTimeMillis();
StringBuilder sb = new StringBuilder();
for (int i = 0; i < loop; i++) {
sb.append(base);
}
String result = sb.toString();
return System.currentTimeMillis() - startTs;
}
}
複製程式碼在三星s8+ 上迴圈拼接 5000 次 smali 字串,得到兩者的耗時大概為 460ms:1ms, 效率差距明顯;
3. smali 迴圈拼接程式碼分析
既然 String 拼接會轉化為 StringBuilder, 理論上來說應該差距不大才對,但實際差距明顯, 猜想可能跟for迴圈有關,我們看下 methodForStr(int loop, String base) 方法的smali程式碼:
.method private methodForStr(ILjava/lang/String;)J
.locals 5
.param p1, "loop" # I 表示引數 loop
.param p2, "base" # Ljava/lang/String;
.line 73
invoke-static {}, Ljava/lang/System;->currentTimeMillis()J # 獲取迴圈起始時間戳
move-result-wide v0
.line 74
.local v0, "startTs":J # v0表示 區域性變數 startTs ,型別為 long
const-string v2, ""
.line 75
.local v2, "result":Ljava/lang/String; # v2 表示區域性變數 result
const/4 v3, 0x0 # 定義for迴圈變數 i 的初始化
.local v3, "i":I
:goto_0 # for迴圈體起始處
if-ge v3, p1, :cond_0 # 若 i >= loop 值,則跳轉到 cond_0 標籤處,退出迴圈,否則繼續執行下面的程式碼
# 以下為for迴圈體邏輯:
# 1. 建立 StringBuilder 物件
# 2. 拼接 result + base 字串, 然後通過 toString() 得到拼接結果
# 3. 將結果再賦值給 result 變數
# 4. 進入下一輪迴圈
.line 76
new-instance v4, Ljava/lang/StringBuilder;
invoke-direct {v4}, Ljava/lang/StringBuilder;-><init>()V
invoke-virtual {v4, v2}, Ljava/lang/StringBuilder;->append(Ljava/lang/String;)Ljava/lang/StringBuilder;
invoke-virtual {v4, p2}, Ljava/lang/StringBuilder;->append(Ljava/lang/String;)Ljava/lang/StringBuilder;
invoke-virtual {v4}, Ljava/lang/StringBuilder;->toString()Ljava/lang/String;
move-result-object v2
# for 迴圈變數i自加1,然後進行下一輪迴圈
.line 75
add-int/lit8 v3, v3, 0x1 # 將第二個暫存器v3中的值加上0x1,然後放入第一個暫存器v3中, 實現自增長
goto :goto_0 # 跳轉到 goto_0 標籤,即: 重新計算迴圈條件, 執行迴圈體
.line 78
.end local v3 # "i":I
:cond_0 # 定義標籤 cond_0
# 迴圈結束後,獲取當前時間戳, 並計算耗時
invoke-static {}, Ljava/lang/System;->currentTimeMillis()J
move-result-wide v3
sub-long/2addr v3, v0
return-wide v3
.end method
複製程式碼根據上面的 smali 程式碼,可以逆推出其原始碼應該為:
private long methodForStr(int loop, String base) {
long startTs = System.currentTimeMillis();
String result = "";
for (int i = 0; i < loop; i++) {
// 每次都在迴圈體中將 String 的拼接改成了 StringBuilder
// 這算是負優化嗎?
StringBuilder sb = new StringBuilder();
sb.append(result);
sb.append(base);
result = sb.toString();
}
return System.currentTimeMillis() - startTs;
}
複製程式碼4. 原始碼分析
4.1 String.java
/*
* Strings are constant; their values cannot be changed after they
* are created. String buffers support mutable strings.
* Because String objects are immutable they can be shared
* */
public final class String
implements java.io.Serializable, Comparable<String>, CharSequence {
// String實際也是char陣列,但由於其用private final修飾,所以不可變(當然,還有其他措施共同保證"不可變")
private final char value[];
}
複製程式碼類註釋描述了其為 immutable ,每個字面量都是一個物件,修改string時,不會在原記憶體處進行修改,而是重新指向一個新物件:
String str = "a"; // String物件 "a"
str = "a" + "a"; // String物件 "aa"
複製程式碼每次進行 + 運算時,都會生成一個新的 String 物件:
// 結合第3部分的smali分析,可以發現:
// 每次for迴圈體中,都會建立一個 `StringBuilder`物件,並生成拼接結果的 `String` 物件;
private long methodForStr(int loop, String base) {
long startTs = System.currentTimeMillis();
String result = "";
for (int i = 0; i < loop; i++) {
result += base;
}
return System.currentTimeMillis() - startTs;
}
複製程式碼在迴圈體中頻繁的建立物件,還會導致大量物件被廢棄,觸發GC,頻繁 stop the world 自然也會導致拼接耗時加長, 如下圖:
4.2 StringBuilder.java
/**
* A mutable sequence of characters. This class provides an API compatible
* with {@code StringBuffer}, but with no guarantee of synchronization.
* */
public final class StringBuilder
extends AbstractStringBuilder
implements java.io.Serializable, CharSequence{}
// StringBuilder 的類註釋指明瞭其實際為一個可變字元陣列, 核心邏輯其實都實現在 AbstractStringBuilder 中了
// 我們看下 stringBuilder.append("str") 是怎麼實現的
abstract class AbstractStringBuilder implements Appendable, CharSequence {
char[] value; // 用於實際儲存字串對應的字元序列
int count; // 已儲存的字元個數
AbstractStringBuilder() {
}
// 提供一個合理的初始化容量大小, 有助於減小擴容次數,提高效率
AbstractStringBuilder(int capacity) {
value = new char[capacity];
}
@Override
public AbstractStringBuilder append(CharSequence s) {
if (s == null)
return appendNull();
if (s instanceof String)
return this.append((String)s);
if (s instanceof AbstractStringBuilder)
return this.append((AbstractStringBuilder)s);
return this.append(s, 0, s.length());
}
public AbstractStringBuilder append(String str) {
if (str == null)
return appendNull();
int len = str.length();
ensureCapacityInternal(count + len); // 確保value陣列有足夠的空間可以儲存變數str的所有字元
str.getChars(0, len, value, count); // 提取變數str中的所有字元,並追加複製到value陣列的最後
count += len;
return this;
}
// 如果當前value陣列容量不夠,進行自動擴容: 建立新陣列,並複製原陣列資料
private void ensureCapacityInternal(int minimumCapacity) {
if (minimumCapacity - value.length > 0) {
value = Arrays.copyOf(value,
newCapacity(minimumCapacity));
}
}
}
// String.java
public final String{
// 從當前字串中複製指定區間的字元到陣列dst dstBegin位後
public void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) {
// 省略部分判斷程式碼
getCharsNoCheck(srcBegin, srcEnd, dst, dstBegin);
}
@FastNative
native void getCharsNoCheck(int start, int end, char[] buffer, int index);
}
複製程式碼從上面原始碼可以看出 StringBuilder 每次 append 字串時,都是在操作同一個 char[] 陣列(無需擴容時),不涉及物件的建立;
5. 是不是所有字串拼接場景都該首選 StringBuilder ?
也不盡然, 比如有些是編譯時常量, 直接用 String 就可以, 即使用 StringBuilder , AS也會提示改為 String 不然反倒浪費;
對於非迴圈拼接字串的場景, 原始碼是用 String 或者 StringBuilder 沒啥區別, 位元組碼中都轉換成 StringBuilder 了;
// 編譯時常量測試
private String methodFixStr() {
return "a" + "a" + "a" + "a" + "a" + "a";
}
private String methodFixSb() {
StringBuilder sb = new StringBuilder();
sb.append("a");
sb.append("a");
sb.append("a");
sb.append("a");
sb.append("a");
return sb.toString();
}
複製程式碼對應的smali程式碼:
.method private methodFixStr()Ljava/lang/String;
.locals 1
.line 100
const-string v0, "aaaaaa" # 編譯器直接優化成最終結果了
return-object v0
.end method
# stringBuilder就沒有優化,還是要一步一步進行拼接
# 這也就是 IDE 提示使用 String 的原因吧
.method private methodFixSb()Ljava/lang/String;
.locals 2
.line 108
new-instance v0, Ljava/lang/StringBuilder;
invoke-direct {v0}, Ljava/lang/StringBuilder;-><init>()V
.line 109
.local v0, "sb":Ljava/lang/StringBuilder;
const-string v1, "a"
invoke-virtual {v0, v1}, Ljava/lang/StringBuilder;->append(Ljava/lang/String;)Ljava/lang/StringBuilder;
.line 110
const-string v1, "a"
invoke-virtual {v0, v1}, Ljava/lang/StringBuilder;->append(Ljava/lang/String;)Ljava/lang/StringBuilder;
.line 111
const-string v1, "a"
invoke-virtual {v0, v1}, Ljava/lang/StringBuilder;->append(Ljava/lang/String;)Ljava/lang/StringBuilder;
.line 112
const-string v1, "a"
invoke-virtual {v0, v1}, Ljava/lang/StringBuilder;->append(Ljava/lang/String;)Ljava/lang/StringBuilder;
.line 113
const-string v1, "a"
invoke-virtual {v0, v1}, Ljava/lang/StringBuilder;->append(Ljava/lang/String;)Ljava/lang/StringBuilder;
.line 114
invoke-virtual {v0}, Ljava/lang/StringBuilder;->toString()Ljava/lang/String;
move-result-object v1
return-object v1
.end method
複製程式碼