New features in Java 8 Update 20 - String deduplication

Strings take up a lot of memory in any application. In particular, char[] arrays containing individual UTF-16 characters contribute the most to JVM memory consumption - because each character takes up 2 bits.

It is actually very common for 30% of the memory to be consumed by strings, not only because strings are the best format for interacting with us, but also because the popular HTTP API uses a lot of strings. With Java 8 Update 20, we now have access to a new feature called string deduplication, which requires the G1 garbage collector, which is turned off by default.

　String deduplication takes advantage of the fact that the interior of the string is actually a char array and is final, so the JVM can manipulate them arbitrarily.

　For string deduplication, developers considered a large number of strategies, but the final implementation adopted the following approach:

　 Whenever the garbage collector accesses the String object, it will mark the char array. It takes the hash value of the char array and stores it with a weak reference to the array. As long as the garbage collector finds another string that has the same hash code as the char array, the two will be compared character by character.

　If they happen to match, then one string will be modified to point to the char array of the second string. The first char array is no longer referenced and can be recycled.

　Of course this whole process brings some overhead, but it is controlled by a very tight upper limit. For example, if a character is not found to be repeated, it will no longer be checked for a period of time.

　So how does this feature actually work? First, you need the just-released Java 8 Update 20, and then follow this configuration: -Xmx256m -XX:+UseG1GC to run the following code:

public class LotsOfStrings {
   
  private static final LinkedList<String> LOTS_OF_STRINGS = new LinkedList<>();
   
  public static void main(String[] args) throws Exception {
    int iteration = 0;
    while (true) {
      for (int i = 0; i < 100; i++) {
        for (int j = 0; j < 1000; j++) {
          LOTS_OF_STRINGS.add(new String("String " + j));
        }
      }
      iteration++;
      System.out.println("Survived Iteration: " + iteration);
      Thread.sleep(100);
    }
  }
}

This code will report an OutOfMemoryError after executing 30 iterations.

Now, enable string deduplication and use the following configuration to run the above code:

-Xmx256m -XX:+UseG1GC -XX:+UseStringDeduplication -XX:+PrintStringDeduplicationStatistics

At this point it can run for a longer time. And it terminates after 50 iterations.

　The JVM now also prints out what it did, let’s take a look:

[GC concurrent-string-deduplication, 4658.2K->0.0B(4658.2K), avg 99.6%, 0.0165023 secs]
   [Last Exec: 0.0165023 secs, Idle: 0.0953764 secs, Blocked: 0/0.0000000 secs]
      [Inspected:          119538]
         [Skipped:              0(  0.0%)]
         [Hashed:          119538(100.0%)]
         [Known:                0(  0.0%)]
         [New:             119538(100.0%)   4658.2K]
      [Deduplicated:       119538(100.0%)   4658.2K(100.0%)]
         [Young:              372(  0.3%)     14.5K(  0.3%)]
         [Old:             119166( 99.7%)   4643.8K( 99.7%)]
   [Total Exec: 4/0.0802259 secs, Idle: 4/0.6491928 secs, Blocked: 0/0.0000000 secs]
      [Inspected:          557503]
         [Skipped:              0(  0.0%)]
         [Hashed:          556191( 99.8%)]
         [Known:              903(  0.2%)]
         [New:             556600( 99.8%)     21.2M]
      [Deduplicated:       554727( 99.7%)     21.1M( 99.6%)]
         [Young:             1101(  0.2%)     43.0K(  0.2%)]
         [Old:             553626( 99.8%)     21.1M( 99.8%)]
   [Table]
      [Memory Usage: 81.1K]
      [Size: 2048, Min: 1024, Max: 16777216]
      [Entries: 2776, Load: 135.5%, Cached: 0, Added: 2776, Removed: 0]
      [Resize Count: 1, Shrink Threshold: 1365(66.7%), Grow Threshold: 4096(200.0%)]
      [Rehash Count: 0, Rehash Threshold: 120, Hash Seed: 0x0]
      [Age Threshold: 3]
   [Queue]
      [Dropped: 0]

For convenience, we don’t need to calculate the sum of all the data ourselves, just use the convenient total.

　The above code snippet stipulates that string deduplication is performed, and it took 16ms to view about 120k strings.

　The above features have just been launched, which means they may not have been fully reviewed. The exact data may look different in actual applications, especially those where strings are used and passed multiple times, so some strings may be skipped or have hashcodes already in them (as you may know, A String hash code is loaded lazily).

　In the above case, all strings were deduplicated, and 4.5MB of data was removed from memory.

　The [Table] section gives statistics about the internal tracking table, and the [Queue] lists how many deduplication requests were dropped due to load, which is also part of the overhead reduction mechanism.

　So, what is the difference between string deduplication and string persistence? There is an article on my blog called how great String Interning is for memory efficiency. In fact, string deduplication and persistence look similar, except that the persistence mechanism reuses the entire string instance, not just the character array.

　The contention of the creators of JDK Enhancement Proposal 192 is that developers often don’t know where to put resident strings, or the appropriate places are hidden by the framework. As I wrote, when copying When deduplicating strings (like country names), you need some common sense. String deduplication is also good for string duplication of applications in the same JVM, which also includes things like XML Schemas, urls, and jar names that are generally not considered Strings will appear multiple times.

When string persistence occurs in the application thread and garbage collection is processed asynchronously and concurrently, string deduplication will not increase runtime consumption. This also explains why We will find Thread.sleep() in the above code. Without sleep, it will add too much pressure to the GC, so that string deduplication will not happen at all. However, this is only a problem that occurs in the sample code. In reality Applications often use a few milliseconds when running string deduplication.