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 ± 1240.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 或更高版本。
- 有一种技术可以通过零拷贝从字节数组实例化字符串。速度快得惊人。
