The document discusses various micro-optimizations that can be made in Java code to improve performance, including: 1. Avoiding boxing/unboxing of primitives, using primitive types instead of object wrappers when possible. 2. Using custom parsing methods instead of built-in String/regex methods like split(), trim(), equals() which have higher overhead. 3. Reducing object allocations by reusing objects/arrays when possible, avoiding unnecessary object creations, and using primitive arrays over object arrays. 4. Leveraging intrinsic methods, avoiding interpretation overhead through direct calls, and bypassing virtual method calls when the implementation is known.

1. Micro optimizations

2. Dmitriy Dumanskiy
Blynk, CTO
Java blog : https://habrahabr.ru/users/doom369/topics
DOU : https://dou.ua/users/DOOM/articles/

3. Makers problem
+ = ?

4. Blynk
10000 req/sec
3 VM * 2 cores, 60$
25% load
10k of local installations

5. Typical Env.
Worst case 256 RAM (~40Mb for heap)
700 MHz, 1 core, ARM

6. ● Typical code
● Plain java
● System is under “highload”
● All “issues” are from open-source
Today talk

7. Problems everybody
knows about

8. ● Primitive wrappers
Typical issues

9. ● Primitive wrappers
● Boxing / Unboxing
Typical issues

10. ● Primitive wrappers
● Boxing / Unboxing
● Regex / Pattern matching
Typical issues

11. ● Primitive wrappers
● Boxing / Unboxing
● Regex / Pattern matching
● String concatenation in loops
Typical issues

12. ● Primitive wrappers
● Boxing / Unboxing
● Regex / Pattern matching
● String concatenation in loops
● Reflection
Typical issues

14. class User {
Date createdAt;
}
What is wrong here?

15. class User {
Date createdAt;
}
Memory consumption

16. class Date {
private transient long fastTime;
private BaseCalendar.Date cdate;
}
More memory

17. class User {
long createdAt;
}
Solution

18. for (String name : list) {
//do something
}
What is wrong here?

19. for (String name : list) {
//do something
}
Iterator allocation

20. Iterator<String> iter = list.iterator();
while (iter.hasNext()) {
String name = iter.next();
}
Iterator allocation

21. Scalar replacement.
Could be.
Or could be not.
Iterator allocation

22. for (int i = 0; i < list.size(); i++) {
Data data = list.get(i);
}
Solution 1

23. for (String s : array) {
//do something
}
Solution 2

24. iterateArray thrpt 168298 ops/s
iterateListWGet thrpt 132292 ops/s
iterateList thrpt 110188 ops/s
Iterator
+50%

25. List<Device> devices = ...;
return devices.get(0);
What is wrong here?

26. List<Device> devices = ...;
return devices.get(0);
Polymorphism

27. invokeInterface
Polymorphism

28. ArrayList<Device> devices = ...;
return devices.get(0);
Solution

29. arrayListGet thrpt 268418 ops/s
listGet thrpt 249005 ops/s
Polymorphism
+7%

30. class User {
Device[] devices = {};
}
What is wrong here?

31. class User {
Device[] devices = {};
}
Allocations

32. {} is new Device[0]
Allocations

33. class User {
final static Device[] EMPTY = {};
Device[] devices = EMPTY;
}
Solution

34. preAllocatedArray thrpt 209423 ops/s
newArrayAllocation thrpt 104293 ops/s
Allocations
+50%

35. void make(String… params)
What is wrong here?

36. void make(String… params)
Allocations

37. String… is new String[] {params}
Allocations

38. void make(String p1)
void make(String p1, String p2)
void make(String p1, String p2, Str p3)
Solution

39. noVarArgs thrpt 7947138 ops/s
varArgs thrpt 4265333 ops/s
Allocations
+2x

40. If (email == null || email.equals(“”)) {
...
}
What is wrong here?

41. If (email == null || email.equals(“”)) {
...
}
Solution

42. If (email == null || email.isEmpty()) {
...
}
Slow equals

43. isEmpty thrpt 364123 ops/s
equals thrpt 231075 ops/s
Slow equals
+60%

44. val.equals(input.toLowerCase());
What is wrong here?

45. val.equals(input.toLowerCase());
Allocations

46. val.equalsIgnoreCase(input);
Solution

47. ignoreCase thrpt 47550 ops/s
toLowerCase thrpt 20339 ops/s
Allocations
+2.3x

48. val.startsWith(input.toLowerCase());
One more case

49. val.regionMatches(true, 0, input, 0, len);
Solution

50. regionMatch thrpt 54924 ops/s
startWithToLowerCase thrpt 14447 ops/s
Allocations
+4x

51. Use strict equals
Solution 2

52. val.split(“0”);
What is wrong here?

53. val.split(“0”);
Split is slow

54. Utils.split(val, ‘0’);
Solution

55. String[] split2(char separator, String body) {
final int i1 = body.indexOf(separator, 1);
if (i1 == -1) {
return new String[] {body};
}
return new String[] {
body.substring(0, i1), body.substring(i1 + 1, body.length())
};
}
Solution

56. customSplit avgt 46 ns/op
split avgt 115 ns/op
Split is slow
+3x

57. return body1.trim() + SEPARATOR +
body2.trim();
What is wrong here?

58. return new StringBuilder()
.append(body1.trim())
.append(SEPARATOR)
.append(body2.trim())
.toString();
What is wrong here?

59. return new StringBuilder()
.append(body1.trim())
.append(SEPARATOR)
.append(body2.trim())
.toString();
Concat optimization

60. String trimmed1 = body1.trim();
String trimmed2 = body2.trim();
return trimmed1 + SEPARATOR +
trimmed2;
Solution 1

61. String trimmed1 = body1.trim();
String trimmed2 = body2.trim();
return new StringBuilder()
.append(trimmed1)
.append(SEPARATOR)
.append(trimmed2)
.toString();
Solution 2

62. optimizedConcat thrpt 44888 ops/s
naiveConcat thrpt 12866 ops/s
Concat optimization
+4x

63. StringBuilder sb = new StringBuilder();
sb.append(body1)
sb.append(SEPARATOR)
sb.append(body2)
return sb.toString();
What is wrong here?

64. StringBuilder sb = new StringBuilder();
sb.append(body1)
sb.append(SEPARATOR)
sb.append(body2)
return sb.toString();
No chaining

65. return new StringBuilder()
.append(body1)
.append(SEPARATOR)
.append(body2)
.toString();
Solution

66. chained thrpt 46279 ops/s
notChained thrpt 27746 ops/s
Chaining
+70%

67. String data = …;
data.getBytes(charset);
What is wrong here?

68. String data = …;
data.getBytes(charset);
Generic Encoding

69. if (charset == UTF_8) {
return decodeUTF8(data);
} else if (charset == US_ASCII) {
return decodeASCII(data);
} else {
return data.getBytes(charset);
}
Solution

70. customGetBytes avgt 155 ns/op
javaGetBytes avgt 233 ns/op
Generic Encoding
+30%

71. if (data == null) {
throw new NoDataException();
}
What is wrong here?

72. if (data == null) {
throw new NoDataException();
}
Exception is expensive

73. Double.parseDouble thrpt 22968 ops/s
Double.parseErr thrpt 737 ops/s
Exception Cost
+30x

74. public Throwable(String message) {
fillInStackTrace();
detailMessage = message;
}
Exception Cost

75. Throwable(String message,
Throwable cause,
boolean enableSuppression,
boolean writableStackTrace)
Exception Cost

76. class MyException extends Exception {
MyException(String message) {
super(message, null, true, false);
}
}
Solution 1

77. final static
MyException cache = new MyException();
Solution 2

78. if (data == null) {
return; //or return code
}
Solution 3

79. try {
double d = Double.parseDouble(s);
} catch (NumberFormatException e) {
}
What is wrong here?

80. try {
double d = Double.parseDouble(s);
} catch (NumberFormatException e) {
}
Allocations

81. ● Does trim()
● Spams ASCIIToBinaryConverter
● Spams exceptions
● Slow
Allocations

82. try {
double d = Utils.parseDouble(s);
} catch (NumberFormatException e) {
}
Solution

83. parseDouble thrpt 22889 ops/s
parseDoubleUtils thrpt 48331 ops/s
Custom parseDouble
+2.2x

84. double d = 11.2321D;
return Math.round(val);
What is wrong here?

85. double d = 11.2321D;
return Math.round(val);
Slow round

86. double d = 11.2321D;
return (int) (val + 0.5);
Solution

87. Slow round
optimizedRound thrpt 383251 ops/s
mathRound thrpt 258123 ops/s
+50%

88. public static int bitCount(int i) {
i = i - ((i >>> 1) & 0x55555555);
i = (i & 0x33333333) + ((i >>> 2) & 0x33333333);
i = (i + (i >>> 4)) & 0x0f0f0f0f;
i = i + (i >>> 8);
i = i + (i >>> 16);
return i & 0x3f;
}
What is wrong here?

90. Integer.bitCount(val);
Solution

91. javaBitCount thrpt 413996 ops/s
manualBitCount thrpt 232490 ops/s
Intrinsics
+80%

92. http://hg.openjdk.java.net/jdk8/jdk8/hotspot/file/87ee5ee275
09/src/share/vm/classfile/vmSymbols.hpp
Intrinsics

93. int[] ar = new int[] {1, -32, 1, 1, 5, 6, 7};
return IntStream.of(ar).anyMatch(i -> i == val)
What is wrong here?

94. int[] ar = new int[] {1, -32, 1, 1, 5, 6, 7};
return IntStream.of(ar).anyMatch(i -> i == val)
Lambda/Stream cost

95. naive thrpt 228002 ops/s
lambda thrpt 22983 ops/s
Lambda/Stream cost
~10x

96. boolean contains(int[] ar, int value) {
for (int arVal : ar) {
if (arVal == value) {
return true;
}
}
return false;
}
Solution

97. E get(int index) {
if (index >= size) {
throw new IndexOutOfBoundsException();
}
return (E) elementData[index];
}
What is wrong here?

98. E get(int index) {
if (index >= size) {
throw new IndexOutOfBoundsException();
}
return (E) elementData[index];
}
Bounds-checking

99. noCheck thrpt 388332 ops/s
boundCheck thrpt 341232 ops/s
Bounds-checking
+12%

100. E get(int index) {
return (E) elementData[index];
}
Solution

101. ● Know your data (jmap, logs, db)
● Know your flows (metrics, jstack)
● Don’t rely on JIT
● Don’t trust java :)
● Always stress test your code
● 1% vs 99%
Summary

102. https://github.com/blynkkk/blynk-server

103. https://github.com/doom369/java-microbenchmarks