Was jeder Java-Entwickler über Strings wissen sollte

Was jeder Java-Entwickler über Strings wissen sollte
Was jeder Java-Entwickler über
Strings wissen sollte
Bernd Müller
Java Forum Nord
20.10.2016
Bernd Müller Java Forum Nord 20.10.2016 1/60

Vor vielen, vielen Jahren . . .

public class HelloWorld {
public static void main(String [] args) {
System.out.println("Hello World");
}
}
Was ist
”
String[]“ ?
Was ist
”
”Hello World”“ ?
Hat das irgend etwas
miteinander zu tun ?

Referent
Vorstellung Referent
Prof. Informatik (Ostfalia, HS Braunschweig/Wolfenbüttel)
Buchautor (JSF, Seam, JPA, ...)
Mitglied EGs JSR 344 (JSF 2.2) und JSR 338 (JPA 2.1)
Geschäftsführer PMST GmbH
. . .

Motivation
Motivation

Motivation

Motivation

¨
©

Motivation
Auszug aus Abschnitt String Interning
”
Strings are, far and away, the most common Java
object; your application’s heap is almost certainly ﬁlled
with them.“

Motivation

Motivation
9
8
6
7

Motivation

Motivation
9
8
6
7

String-Klassen
String-Klassen und -Methoden

String-Klassen
Klassen mit String-Bezug: die üblichen Verdächtigen
java.lang.String, seit Java 1.0
The String class represents character strings.
java.lang.StringBuffer, seit Java 1.0
A thread-safe, mutable sequence of characters.
java.lang.StringBuilder, seit Java 5
A mutable sequence of characters.
java.util.StringTokenizer, seit Java 1.0
The string tokenizer class allows an application to break a
string into tokens.
java.util.StringJoiner, seit Java 8
StringJoiner is used to construct a sequence of characters
separated by a delimiter . . .

String-Klassen
Padding
Padding in der Regel mit Apache Commons-Lang
StringUtils: leftPad(), rightPad()
Man ben¨otigt aber keine Bibliothek, ist im SDK eingebaut
Schl¨ussel: java.util.Formatter als printf-Nachahmung
Beispiel:
String.format(%1 $10s, hello)
String.format(%1$-10s, hello)

Character-Codierungen

Historisch Java mit 16 Bit codiertem char-Datentyp
Mit Java 5 wurde Unicode 4.0 als Character-Codierung
eingeführt [CHAR1]
Damit Codierungen mit mehr als 16 Bit möglich, die als
sogenannte Surrogate repräsentiert werden

Java Tutorial: Supplementary Characters as Surrogates
”
To support supplementary characters without changing the char
primitive data type and causing incompatibility with previous Java
programs, supplementary characters are defined by a pair of code
point values that are called surrogates. The first code point is from
the high surrogates range of U+D800 to U+DFBB, and the
second code point is from the low surrogates range of U+DC00 to
U+DFFF. For example, the Deseret character LONG I, U+10400,
is defined with this pair of surrogate values: U+D801 and
U+DC00.“ [CHAR2]

Character-Codierungen (cont’d)
Beschreibung in Java-Doc java.lang.Character [CHAR4]
¨Uberblick
Java 1.4: Unicode 3.0
Java 5: Unicode 4.0
Java 6: Unicode 4.0
Java 7: Unicode 6.0.0
Basic Encodings in lib/rt.jar, Extended Encodings in
lib/charsets.jar, Dokumentation in [CHAR3]

Performanz
Performanz

Performanz
Performanz: toString()

Performanz
Who Cares About toString Performance ?
Blog von Antonio Goncalves [Gonc]
Use Case: Großer Batch mit Logging und toString(), o.¨a.
Eﬀective Java [Joshua Bloch]
Item 10: Always override toString
toString()-Methode durch IDE generiert oder selbst
gemacht mit Alternativen
Null-Checks nicht vergessen
Untersucht: JDK, Guava, CommonsLang3
Gemessen:
”
Average performance with Java
Microbenchmarking Harness (ops/s)“

Performanz
Who Cares About toString Performance ? (cont’d)
Ergebnisse
Technic Average ops/s
String concat with + 142.075,167
String builder 141.463,438
Objects.toString 140.791,365
Guava 110.111,808
ToStringBuilder (append) 75.165,552
ToStringBuilder (reﬂectionToString) 34.930,630
ReﬂectionToStringBuilder 23.204,479

Performanz
Who Cares About toString Performance? (cont’d)
Zusammenfassung:
”
Today with the JVM optimisation, we can safely use
the + symbol to concatenate Strings (and use
Objects.toString to handle nulls). With the utility class
Objects that is built-in the JDK, no need to have external
frameworks to deal with null values. So, out of the box,
the JDK has better performance than any other technic
described in this article.“ [Antonio Goncalves, Gonc]
Nachtrag: sowieso nur interessant, wenn Sie toString() sehr oft
aufrufen

Performanz
Performanz: String-Konkatenation

JDK String-Konkatenation
@Benchmark
// String +
public static String concat () {
String result = ;
for (int i = 0; i IT; i++) {
result += i;
}
return result;
}
@Benchmark
// StringBuffer
StringBuffer builder = new Stri
for (int i = 0; i IT; i++) {
builder.append(i);
}
return builder.toString ();
}
@Benchmark
// Joining Collector
return IntStream.range (0, IT)
.mapToObj(String :: valueOf)
.collect(Collectors.joining ());
}
@Benchmark
// StringBuilder
StringBuilder builder = new Str
for (int i = 0; i IT; i++) {
builder.append(i);
}
return builder.toString ();
}

Performanz
JMH Ergebnisse
Benchmark Score Error Units
SC.concatWithJoiningCollector 2898,767 ± 5,378 ops/s
SC.concatWithString 25,434 ± 0,059 ops/s
SC.concatWithStringBuﬀer 5375,578 ± 39,959 ops/s
SC.concatWithStringBuilder 6030,804 ± 13,088 ops/s

Internte Strings
Internte Strings

Internte Strings
Was ist das ?
Internte Strings — Was ist das ?

Internte Strings
Was ist das ?
Internte Strings
Moreover, a string literal always refers to the same instance of
class String. This is because string literals - or, more generally,
strings that are the values of constant expressions (§15.28) - are
”interned” so as to share unique instances, using the method
String.intern. [JLS 3.10.5 String Literals]
String-Memory-Pool mit allen internten Strings
Beim Laden einer Klasse in die VM wird gepr¨uft, ob
String-Literal schon im Pool
Falls ja, wird es wiederverwendet, falls nein, neu eingetragen
String-Literale gibt es also nur einmal in einer VM

Internte Strings
Was ist das ?
Internte String-Literale — Beispiele
String str1 = Hello , World!;
String str2 = Hello , World!;
String str3 = new String(Hello , World!); // sinnlos
Assert.assertSame(Hello , World!, Hello , World!);
Assert.assertSame(str1 , str2 );
Assert.assertSame(Hel + lo, Hel + lo);
Assert.assertNotSame(str1 + str1 , str2 + str2 );
Assert.assertEquals(str1 + str1 , str2 + str2 );
Assert.assertSame (( str1 + str1 ). intern (),
(str2 + str2 ). intern ());
Assert.assertNotSame(str1 , str3 );

Internte Strings
Am¨usantes
Am¨usantes

Internte Strings
Am¨usantes
Spielereien
Was ist die Ausgabe?
System.out.println(Hello , World!);
magic ();
private static void magic () throws Exception {
Field field = String.class
. getDeclaredField (value);
field.setAccessible(true );
field.set(Hello , World!,
tricky intern.toCharArray ());
}
Zuerst gesehen bei Arno Haase
Bitte nicht nachmachen

Internte Strings
Am¨usantes
Spielereien (cont’d)
Was ist die Ausgabe?
magic ();
public static void magic () throws Exception {
Field field = String.class
. getDeclaredField (value);
char [] chars = (char []) field.get(Hello World);
System.arraycopy(tricky intern.toCharArray (),
0, chars , 0, chars.length );
}
Ebenfalls nicht nachmachen

Internte Strings
Nochmal Performanz
Nochmal Performanz

Internte Strings
Nochmal Performanz
Java-Doc String.intern()
Returns a canonical representation for the string object.
A pool of strings, initially empty, is maintained privately by the class
String.
When the intern method is invoked, if the pool already contains a string
equal to this String object as determined by the equals(Object) method,
then the string from the pool is returned. Otherwise, this String object is
added to the pool and a reference to this String object is returned.
It follows that for any two strings s and t, s.intern() == t.intern() is true
if and only if s.equals(t) is true.
All literal strings and string-valued constant expressions are interned.
String literals are deﬁned in section 3.10.5 of the The JavaTM
Language
Speciﬁcation.
Returns: a string that has the same contents as this string, but is
guaranteed to be from a pool of unique strings.

Internte Strings
Nochmal Performanz
Performanz-Idee: String-Interning und Equals
”
On the topic of interning strings, what about using the intern()
method to make the programm run faster, since interned strings
can be compared via the == operator? That is a popular thought,
though in most cases it turns out to by a myth. The
String.equals() method is pretty fast.
. . .
Comparing strings via the == operator is undeniably faster, but the
cost of interning the string must also be taken into consideration.“
[Java Performance, Scott Oaks]

Internte Strings
Nochmal Performanz
Java Performance, Scott Oaks
”
Like most optimizations, interning strings shouldn’t
be done arbitrarily, but it can be eﬀective if there are lots
of duplicate strings occupying a signiﬁcant portion of the
heap.“

Internte Strings
Und nochmal Performanz

Internte Strings
Auch bitte nicht selbst versuchen: MyString
”
In compiler theory, an intrinsic function is a function available for
use in a given programming language whose implementation is
handled specially by the compiler. Typically, it substitutes a
sequence of automatically generated instructions for the original
function call, similar to an inline function. Unlike an inline function
though, the compiler has an intimate knowledge of the intrinsic
function and can therefore better integrate it and optimize it for
the situation.“[Wikipedia,Intr1]
In Java Compiler, JIT, evtl. sogar in JVM eingebaut
String.equals() ist intrinsic. String.indexOf(),
String.compareTo() ebenfalls [Krystal Mo,Intr2]
String.intern() ist sogar nativ implementiert

Internte Strings
Implementierung
Implementierung

Internte Strings
Implementierung
Der String-Pool
Implementiert als Hashtable fester Größe
Bucket-Größe ab Java 6 einstellbar
Nativ in JVM realisiert, Größe nicht veränderbar
In Java 6 in Permanent Generation, 7 und höher im Heap
Daher in Java 6 OOME: PermGen space
Java 7 und höher OOME: Java heap space
Größen:
Vor Java 7u40 1009 Buckets
Java 7u40 und später 60013
VM-Schalter:
-XX:StringTableSize=value
-XX:+PrintStringTableStatistics (Java 7u6 und größer,
6u32 Backport)

Beispiele -XX:+PrintStringTableStatistics
StringTable statistics:
Number of buckets : 1003
Average bucket size : 33
Variance of bucket size : 33
Std. dev. of bucket size: 6
Maximum bucket size : 51
Schlecht
Maximum bucket size : 10Viel besser
Empfehlenswert

In Java 8 ausf¨uhrlichere Informationen
Number of buckets : 60013 = 480104 bytes , avg 8,000
Number of entries : 797 = 19128 bytes , avg 24 ,000
Number of literals : 797 = 151960 bytes , avg 190 ,665
Total footprint : = 651192 bytes
Average bucket size : 0,013
Variance of bucket size : 0,013
Std. dev. of bucket size: 0,115

GC1 String-Deduplication
GC1 + JVM-Optionen

JEP 192: String Deduplication in G1 [JEP192]
Summary
”
Reduce the Java heap live-data set by enhancing the G1 garbage
collector so that duplicate instances of String are automatically
and continuously deduplicated. “
Motivation
”
. . . Measurements have shown that roughly 25% of the Java heap
live data set in these types of applications is consumed by String
objects. . . . roughly half of those String objects are duplicates
. . . Having duplicate String objects on the heap is, essentially, just
a waste of memory“
Description
”
The value field is implementation-specific and not observable
from outside . . . This means that it can safely and transparently be
used by multiple instances of String at the same time.
Deduplicating a String object is conceptually just an re-assignment
of the value field, i.e., aString.value = anotherString.value.

-XX:+UseG1GC -XX:+UseStringDeduplication
String tmp = some string;
String string1 = new String(tmp + tmp);
String string2 = new String(tmp + tmp);
Field field = String.class. getDeclaredField (value);
Assert.assertEquals(string1 , string2 );
Assert.assertNotSame(string1 , string2 );
Assert.assertNotSame(field.get(string1),
field.get(string2 ));
System.gc();
Thread.sleep (1000);
Assert.assertNotSame(string1 , string2 );
Assert.assertSame(field.get(string1),
field.get(string2 ));

GC1 String-Deduplication
Erfahrungsbericht
Artikel G1: from garbage collector to waste management
consultant
von Erik Costlow, 24.3.2016, Java Platform Group, Product
Management blog
Aussage: String Deduplication may decrease heap usage by
about 10%
Am Beispiel Eclipse
Referenz: [DEDUP]
Seit Neon in eclipse.ini

Dies und das
Dies und das

Dies und das
Heinz Kabutz, Reflection Madness, JAX London 2014
Java 1.0 - 1.2
String contained char[], offset, count
Java 1.3 - 1.6
Added a cached hash code
String became a shared, mutable, but thread-safe class
Java 1.7
Got rid of offset and length and added hash32
Java 1.8
Got rid of hash32 again

Dies und das
Andere String-relevante VM-Optionen
-XX:+UseStringCache
”
Enables caching of commonly allocated strings.“
Keine weiteren Informationen gefunden. Vorhanden in Java 6
und 7. Entfernt in Java 8
-XX:+UseCompressedStrings
”
Use a byte[] for Strings which can be represented as pure
ASCII.“
Eingef¨uhrt in Java 6u21. Wieder entfernt in Java 7
-XX:+OptimizeStringConcat
”
Optimize String concatenation operations where possible.“
Eingef¨uhrt in Java 6u20. Optimiert wiederholte StringBuilder
append()-Aufrufe

Dies und das
Ausblick — es geht immer weiter . . .
JEP 254: Compact Strings [JEP254]
Bereits 8/2014 deﬁniert
”
Wiederbelebung“ von -XX:+UseCompressedStrings
kodiert Zeichen als ISO-8859-1/Latin-1 (1 Byte pro Zeichen)
oder UTF-16 (2 Bytes pro Zeichen)
Marker zur Kennzeichnung
JavaOne 2015, CON5483: Compact Strings: A
Memory-Eﬃcient Internal Representation for Strings
Gemeinsames Projekt von Oracle und Intel, 10+ Entwickler
Kommt in Java 9. In neueren EAs enthalten

Dies und das
Wer an Schnittstellen vorbei programmiert,
ist selbst schuld . . .
Große Diskussion: sun.misc.Unsafe
Hier: magic(), in Abschnitt Am¨usantes
. . . schauen wir uns die Details an . . .

Dies und das
String-Interna vor JEP 254
/** The value is used for character storage. */
private final char value [];

String-Interna nach JEP 254
/**
* 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;
/**
* The identifier of the encoding used to encode the bytes in
* {@code value }. The supported values in this implementation are
*
* LATIN1
* UTF16
*
* @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 .
*/
private final byte coder;

Dies und das
magic() ¨uberarbeitet
Wirft mit Java 9 Exception:
java.lang. IllegalArgumentException : Can not set
final [B field java.lang.String.value to [C
¨Uberarbeitung: aus
field. setAccessible (true );
field.set(Hello , World!, tricky intern.toCharArray ());
}
wird
field. setAccessible (true );
field.set(Hello , World!, tricky intern.getBytes ());
}

Fragen und Anmerkungen
Fragen und Anmerkungen

Referenzen
Referenzen

Referenzen
Referenzen
[Gonc] Antonio Goncalves: Who Cares About toString
Performance?
[Intr1] Wikipedia: Intrinsic function
[Intr2] Krystal Mo. Intrinsic Methods in HotSpot VM
[Bug1] JDK-6962931: move interned strings out of the perm gen
[Bug2] JDK-6964458: Reimplement class meta-data storage to use
native memory
[Bug3] JDK-4513622: (str) keeping a substring of a ﬁeld prevents
GC for object
[JEP192] JEP 192: String Deduplication in G1
[JEP254] JEP 254: Compact Strings
[DEDUP] G1: from garbage collector to waste management
consultant

Referenzen
Referenzen (cont’d)
[CHAR1] Supplementary Characters in the Java Platform
[CHAR2] Supplementary Characters as Surrogates
[CHAR3] Unicode Character Representations
[CHAR4] Supported Encodings
[CHAR5] Unicode 4.0 support in J2SE 1.5

Was jeder Java-Entwickler über Strings wissen sollte

Weitere ähnliche Inhalte

Andere mochten auch (20)

Ähnlich wie Was jeder Java-Entwickler über Strings wissen sollte (20)

Mehr von berndmueller (6)

Was jeder Java-Entwickler über Strings wissen sollte