java.lang.string 可能是 java 中最常用的类之一。当然，它内部包含其字符串数据。但是，您知道这些数据实际上是如何存储的吗？在这篇文章中，我们将探讨 java.lang.string 的内部结构并讨论提高实例化性能的方法。
java 8 或更早版本中 java.lang.string 的内部结构
在 java 8 中，java.lang.string 将其字符串数据包含为 16 位字符数组。
public final class string
implements java.io.serializable, comparable<string>, charsequence {
/** the value is used for character storage. */
private final char value[];
从字节数组实例化 string 时，最终会调用 stringcoding.decode()。
public string(byte bytes[], int offset, int length, charset charset) {
if (charset == null)
throw new nullpointerexception("charset");
checkbounds(bytes, offset, length);
this.value = stringcoding.decode(charset, bytes, offset, length);
}
对于us_ascii，最终会调用sun.nio.cs.us_ascii.decoder.decode()，将源字节数组的字节一一复制到char数组中。
public int decode(byte[] src, int sp, int len, char[] dst) {
int dp = 0;
len = math.min(len, dst.length);
while (dp < len) {
byte b = src[sp++];
if (b >= 0)
dst[dp++] = (char)b;
else
dst[dp++] = repl;
}
return dp;
}
新创建的 char 数组用作新 string 实例的 char 数组值。
正如您所注意到的，即使源字节数组仅包含单字节字符，也会发生字节到字符的复制迭代。
java 9或更高版本中java.lang.string的内部结构
在 java 9 或更高版本中，java.lang.string 将其字符串数据包含为 8 位字节数组。
public final class string
implements java.io.serializable, comparable<string>, charsequence {
/**
* the value is used for character storage.
*
* @implnote this field is trusted by the vm, and is a subject to
* constant folding if string instance is constant. overwriting this
* field after construction will cause problems.
*
* additionally, it is marked with {@link stable} to trust the contents
* of the array. no other facility in jdk provides this functionality (yet).
* {@link stable} is safe here, because value is never null.
*/
@stable
private final byte[] value;
从字节数组实例化 string 时，还会调用 stringcoding.decode()。
public string(byte bytes[], int offset, int length, charset charset) {
if (charset == null)
throw new nullpointerexception("charset");
checkboundsoffcount(offset, length, bytes.length);
stringcoding.result ret =
stringcoding.decode(charset, bytes, offset, length);
this.value = ret.value;
this.coder = ret.coder;
}
对于 us_ascii，调用 stringcoding.decodeascii()，它使用 arrays.copyofrange() 复制源字节数组，因为源和目标都是字节数组。 arrays.copyofrange() 内部使用 system.arraycopy()，这是一个本机方法并且速度非常快。
private static result decodeascii(byte[] ba, int off, int len) {
result result = resultcached.get();
if (compact_strings && !hasnegatives(ba, off, len)) {
return result.with(arrays.copyofrange(ba, off, off + len),
latin1);
}
byte[] dst = new byte[len<<1];
int dp = 0;
while (dp < len) {
int b = ba[off++];
putchar(dst, dp++, (b >= 0) ? (char)b : repl);
}
return result.with(dst, utf16);
}
您可能会注意到 compact_strings 常量。 java 9 中引入的这一改进称为紧凑字符串。该功能默认启用，但您可以根据需要禁用它。详情请参阅https://docs.oracle.com/en/java/javase/17/vm/java-hotspot-virtual-machine-performance-enhancements.html#guid-d2e3dc58-d18b-4a6c-8167-4a1dfb4888e4。
立即学习“Java免费学习笔记（深入）”；
java 8、11、17 和 21 中 new string(byte[]) 的性能
我编写了这个简单的 jmh 基准代码来评估 new string(byte[]) 的性能：
@state(scope.benchmark)
@outputtimeunit(timeunit.milliseconds)
@fork(1)
@measurement(time = 3, iterations = 4)
@warmup(iterations = 2)
public class stringinstantiationbenchmark {
private static final int str_len = 512;
private static final byte[] single_byte_str_source_bytes;
private static final byte[] multi_byte_str_source_bytes;
static {
{
stringbuilder sb = new stringbuilder();
for (int i = 0; i < str_len; i++) {
sb.append("x");
}
single_byte_str_source_bytes = sb.tostring().getbytes(standardcharsets.utf_8);
}
{
stringbuilder sb = new stringbuilder();
for (int i = 0; i < str_len / 2; i++) {
sb.append("あ");
}
multi_byte_str_source_bytes = sb.tostring().getbytes(standardcharsets.utf_8);
}
}
@benchmark
public void newstrfromsinglebytestrbytes() {
new string(single_byte_str_source_bytes, standardcharsets.utf_8);
}
@benchmark
public void newstrfrommultibytestrbytes() {
new string(multi_byte_str_source_bytes, standardcharsets.utf_8);
}
}
基准测试结果如下：
- java 8
benchmark mode cnt score error units newstrfrommultibytestrbytes thrpt 4 1672.397 ± 11.338 ops/ms newstrfromsinglebytestrbytes thrpt 4 4789.745 ± 553.865 ops/ms
- java 11
benchmark mode cnt score error units newstrfrommultibytestrbytes thrpt 4 1507.754 ± 17.931 ops/ms newstrfromsinglebytestrbytes thrpt 4 15117.040 ± 1241240.981 ops/ms
- java 17
benchmark mode cnt score error units newstrfrommultibytestrbytes thrpt 4 1529.215 ± 168.064 ops/ms newstrfromsinglebytestrbytes thrpt 4 17753.086 ± 251.676 ops/ms
- java 21
benchmark mode cnt score error units newstrfrommultibytestrbytes thrpt 4 1543.525 ± 69.061 ops/ms newstrfromsinglebytestrbytes thrpt 4 17711.972 ± 1178.212 ops/ms
newstrfromsinglebytestrbytes() 的吞吐量从 java 8 到 java 11 得到了极大的提高。这可能是因为 string 类中从 char 数组更改为 byte 数组。
通过零复制进一步提高性能
好的，紧凑字符串是一个很大的性能改进。但是从字节数组实例化 string 的性能没有提高的空间吗？ java 9 或更高版本中的 string(byte bytes[], int offset, int length, charset charset) 复制字节数组。即使它使用 system.copyarray() 这是一个原生方法并且速度很快，但也需要一些时间。
当我阅读 apache fury 的源代码时，它是“一个由 jit（即时编译）和零拷贝驱动的极快的多语言序列化框架”，我发现他们的 stringserializer 实现了零拷贝字符串实例化。让我们看看具体的实现。
stringserializer的用法如下：
import org.apache.fury.serializer.stringserializer;
...
byte[] bytes = "hello".getbytes();
string s = stringserializer.newbytesstringzerocopy(latin1, bytes);
stringserializer.newbytesstringzerocopy()最终实现的是调用非public string构造函数new string(byte[], byte coder)，将源字节数组直接设置为string.value，而不需要复制字节。
stringserializer 有以下 2 个常量：
private static final bifunction<byte[], byte, string> bytes_string_zero_copy_ctr =
getbytesstringzerocopyctr();
private static final function<byte[], string> latin_bytes_string_zero_copy_ctr =
getlatinbytesstringzerocopyctr();
bytes_string_zero_copy_ctr 被初始化为从 getbytesstringzerocopyctr() 返回的 bifunction：
private static bifunction<byte[], byte, string> getbytesstringzerocopyctr() {
if (!string_value_field_is_bytes) {
return null;
}
methodhandle handle = getjavastringzerocopyctrhandle();
if (handle == null) {
return null;
}
// faster than handle.invokeexact(data, byte)
try {
methodtype instantiatedmethodtype =
methodtype.methodtype(handle.type().returntype(), new class[] {byte[].class, byte.class});
callsite callsite =
lambdametafactory.metafactory(
string_look_up,
"apply",
methodtype.methodtype(bifunction.class),
handle.type().generic(),
handle,
instantiatedmethodtype);
return (bifunction) callsite.gettarget().invokeexact();
} catch (throwable e) {
return null;
}
}
该方法返回一个 bifunction，它接收 byte[] 值、字节编码器作为参数。该函数调用 methodhandle
对于 string 构造函数 new string(byte[] value, byte coder)。我不知道通过 lambdametafactory.metafactory() 调用 methodhandle 的技术，但它看起来比 methodhandle.invokeexact() 更快。
latin_bytes_string_zero_copy_ctr 被初始化为从 getlatinbytesstringzerocopyctr() 返回的函数：
private static function<byte[], string> getlatinbytesstringzerocopyctr() {
if (!string_value_field_is_bytes) {
return null;
}
if (string_look_up == null) {
return null;
}
try {
class<?> clazz = class.forname("java.lang.stringcoding");
methodhandles.lookup caller = string_look_up.in(clazz);
// jdk17 removed this method.
methodhandle handle =
caller.findstatic(
clazz, "newstringlatin1", methodtype.methodtype(string.class, byte[].class));
// faster than handle.invokeexact(data, byte)
return _jdkaccess.makefunction(caller, handle, function.class);
} catch (throwable e) {
return null;
}
}
该方法返回一个接收 byte[]（不需要编码器，因为它仅适用于 latin1）作为参数的函数，如 getbytesstringzerocopyctr()。但是，这个函数调用 methodhandle
改为 stringcoding.newstringlatin1(byte[] src) 。 _jdkaccess.makefunction() 使用 lambdametafactory.metafactory() 以及 getbytesstringzerocopyctr() 包装 methodhandle 的调用。
stringcoding.newstringlatin1() 在 java 17 中被删除。因此，在 java 17 或更高版本中使用 bytes_string_zero_copy_ctr 函数，否则使用 latin_bytes_string_zero_copy_ctr 函数。
stringserializer.newbytesstringzerocopy() 基本上正确调用了存储在常量中的这些函数。
public static string newbytesstringzerocopy(byte coder, byte[] data) {
if (coder == latin1) {
// 700% faster than unsafe put field in java11, only 10% slower than `new string(str)` for
// string length 230.
// 50% faster than unsafe put field in java11 for string length 10.
if (latin_bytes_string_zero_copy_ctr != null) {
return latin_bytes_string_zero_copy_ctr.apply(data);
} else {
// jdk17 removed newstringlatin1
return bytes_string_zero_copy_ctr.apply(data, latin1_boxed);
}
} else if (coder == utf16) {
// avoid byte box cost.
return bytes_string_zero_copy_ctr.apply(data, utf16_boxed);
} else {
// 700% faster than unsafe put field in java11, only 10% slower than `new string(str)` for
// string length 230.
// 50% faster than unsafe put field in java11 for string length 10.
// `invokeexact` must pass exact params with exact types:
// `(object) data, coder` will throw wrongmethodtypeexception
return bytes_string_zero_copy_ctr.apply(data, coder);
}
}
要点是：
- 调用非公共 stringcoding.newstringlatin1() 或 new string(byte[] value, byte coder) 以避免字节数组复制
- 尽可能减少反射成本。
是时候进行基准测试了。我更新了 jmh 基准代码如下：
- 构建.gradle.kts
dependencies {
implementation("org.apache.fury:fury-core:0.9.0")
...
- org/komamitsu/stringinstantiationbench/stringinstantiationbenchmark.java
package org.komamitsu.stringinstantiationbench;
import org.apache.fury.serializer.stringserializer;
import org.openjdk.jmh.annotations.*;
import java.nio.charset.standardcharsets;
import java.util.concurrent.timeunit;
@state(scope.benchmark)
@outputtimeunit(timeunit.milliseconds)
@fork(1)
@measurement(time = 3, iterations = 4)
@warmup(iterations = 2)
public class stringinstantiationbenchmark {
private static final int str_len = 512;
private static final byte[] single_byte_str_source_bytes;
private static final byte[] multi_byte_str_source_bytes;
static {
{
stringbuilder sb = new stringbuilder();
for (int i = 0; i < str_len; i++) {
sb.append("x");
}
single_byte_str_source_bytes = sb.tostring().getbytes(standardcharsets.utf_8);
}
{
stringbuilder sb = new stringbuilder();
for (int i = 0; i < str_len / 2; i++) {
sb.append("あ");
}
multi_byte_str_source_bytes = sb.tostring().getbytes(standardcharsets.utf_8);
}
}
@benchmark
public void newstrfromsinglebytestrbytes() {
new string(single_byte_str_source_bytes, standardcharsets.utf_8);
}
@benchmark
public void newstrfrommultibytestrbytes() {
new string(multi_byte_str_source_bytes, standardcharsets.utf_8);
}
// copied from org.apache.fury.serializer.stringserializer.
private static final byte latin1 = 0;
private static final byte latin1_boxed = latin1;
private static final byte utf16 = 1;
private static final byte utf16_boxed = utf16;
private static final byte utf8 = 2;
@benchmark
public void newstrfromsinglebytestrbyteswithzerocopy() {
stringserializer.newbytesstringzerocopy(latin1, single_byte_str_source_bytes);
}
@benchmark
public void newstrfrommultibytestrbyteswithzerocopy() {
stringserializer.newbytesstringzerocopy(utf8, multi_byte_str_source_bytes);
}
}
结果如下：
- java 11
benchmark mode cnt score error units newstrfrommultibytestrbytes thrpt 4 1505.580 ± 13.191 ops/ms newstrfrommultibytestrbyteswithzerocopy thrpt 4 2284141.488 ± 5509.077 ops/ms newstrfromsinglebytestrbytes thrpt 4 15246.342 ± 258.381 ops/ms newstrfromsinglebytestrbyteswithzerocopy thrpt 4 2281817.367 ± 8054.568 ops/ms
- java 17
benchmark mode cnt score error units newstrfrommultibytestrbytes thrpt 4 1545.503 ± 15.283 ops/ms newstrfrommultibytestrbyteswithzerocopy thrpt 4 2273566.173 ± 10212.794 ops/ms newstrfromsinglebytestrbytes thrpt 4 17598.209 ± 253.282 ops/ms newstrfromsinglebytestrbyteswithzerocopy thrpt 4 2277213.103 ± 13380.823 ops/ms
- java 21
benchmark mode cnt score error units newstrfrommultibytestrbytes thrpt 4 1556.272 ± 16.482 ops/ms newstrfrommultibytestrbyteswithzerocopy thrpt 4 3698101.264 ± 429945.546 ops/ms newstrfromsinglebytestrbytes thrpt 4 17803.149 ± 204.987 ops/ms newstrfromsinglebytestrbyteswithzerocopy thrpt 4 3817357.204 ± 89376.224 ops/ms
由于 npe，java 8 的基准测试代码失败。可能是我用的方法不对。
stringserializer.newbytesstringzerocopy() 的性能在 java 17 中比普通 new string(byte[] bytes, charset charset) 快 100 多倍，在 java 21 中快 200 多倍。也许这就是 fury 速度如此之快的秘密之一。
使用这种零复制策略和实现的一个可能的问题是传递给 new string(byte[] value, byte coder) 的字节数组可能由多个对象拥有；新的 string 对象和引用字节数组的对象。
byte[] bytes = "Hello".getBytes();
String s = StringSerializer.newBytesStringZeroCopy(LATIN1, bytes);
System.out.println(s); // >>> Hello
bytes[4] = '!';
System.out.println(s); // >>> Hell!
这种可变性可能会导致字符串内容意外更改的问题。
结论
- 如果您使用 java 8，就 string 实例化的性能而言，请尽可能使用 java 9 或更高版本。
- 有一种技术可以通过零拷贝从字节数组实例化字符串。速度快得惊人。
