My JeeConf talk regarding small optimization hacks that may improve your code performance in java.

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