“javalangString”内部：理解和优化实例化性能

php中文网 2024-12-09 17:53:03

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

以上就是“javalangString”内部：理解和优化实例化性能的详细内容，更多请关注php中文网其它相关文章！

本文地址： http://www.ipsmc.com/java/20149.html