A healthy diet for your Java application Devoxx France.pdf

A healthy diet
for your Java
application
Marharyta Nedzelska, @jMargaritaN
17.04.2024

Marharyta Nedzelska
Software Engineer @ Sonar
Conferences speaker & organizer
Java/Kotlin/Scala/...
Twitter: @jMargaritaN

https://www.freepik.com/vectors/ukraine-war
Ukraine war vector created by starline - www.freepik.com

Aleksey Shipilëv
Principal Engineer, Languages
and Runtimes, Amazon Web
Services
OpenJDK
JMH, JCStress, JOL

https://sonarcloud.io/project/overview?id=shipilev_jdk

I want to analyze Java & C++
code of OpenJDK in SonarCloud
…
using 3 Gb of RAM.
But I can’t :(
Aleksey Shipilëv

Am I making my
application “ﬁt” too?

Is there any problem?
How to make your app “ﬁt”?

Garbage Collector is not a wizard
I can’t collect objects that are
still referenced!

Body
● Clothes too small
● Fat % too high
● Difﬁcult to
run/walk/breathe
● BMI too high
● Always hungry
● Not satisﬁed with the
appearance…
● OutOfMemoryError
● More memory doesn’t help
● Much time on GC (GC
pauses)
● Spending too much CPU
● …
Application

Let’s measure

Body
● Weight
● Fat & muscles
● BMI
● Heart rate
● Blood tests
● Eating habits
● …
● Memory usage
● Time
● CPU usage
● Heapdump
● Logs
● …
Application

Here are the heapdump, logs
and some memory analysis to
help you investigate…
Aleksey Shipilëv

java.lang.OutOfMemoryError: GC overhead limit exceeded
at com.google.protobuf.Utf8$UnsafeProcessor.decodeUtf8(na:2669)
at com.google.protobuf.Utf8.decodeUtf8(na:2905)
…
at com.sonar.A.D.A(na:648)
at com.sonar.A.D.B(na:2257)
at com.sonar.A.D.A(na:3069)
at com.sonar.cpp.F.readUcfg(na:2348)

Let’s measure
Let’s analyze

When static ﬁelds are eligible for garbage collection?
A) When the last instance is collected
B) When Class<.> instance is collected
C) When JVM exits
D) When class is unloaded
E) None of the above
32

C) When JVM exits
33

Instance Class Classloader
Static ﬁeld

C) When JVM exits
F) When classloader is collected
38

Static is like sugar
● Static members live almost “forever”
● Static members should be avoided
● Static members shouldn’t be mutable
● Static members shouldn’t be updated from non-static methods

Let’s measure
Let’s analyze
Find the root cause

equals() / hashCode() - carbs
● Should be used properly
● Always override equals() and hashCode() together
● Contract: if equals() returns true, hashCode() must be the same
● HashMap keys must be immutable

● https://jqno.nl/equalsveriﬁer/
● https://github.com/jqno/equalsveriﬁer

@Test
void test() {
EqualsVerifier
.forClass(FullName.class)
.verify();
}

Let’s measure
Let’s analyze
Find the root cause
Fix it

Inner classes
● Should be static
● If still need it, take care of the lifecycle and outer class reference

ThreadLocals
● ThreadLocal lives as long as thread is alive
● Should be unset manually

Let’s measure
Let’s analyze
Find the root cause
Fix it
Improve

Memory leaks Vs Memory footprint

Memory leak
A memory leak is an
unintentional form of
memory consumption
whereby the developer fails
to free an allocated block of
memory when no longer
needed.
- OWASP

Memory footprint
Memory footprint refers to
the amount of main
memory that a program
uses or references while
running.
- Wikipedia

Fixing memory leaks Reducing memory footprint

Reducing memory footprint
● Remove references manually
● Custom classloaders

try(var loader = new CustomClassloader(Example1.class.getClassLoader())) {
var clazz = loader.loadClass("com.example.classloader.MyExampleClass");
var instance = clazz.getConstructor().newInstance();
clazz.getMethod("doSomething").invoke(instance);
} catch (Exception e) {
throw new RuntimeException(e);
}

● Minimize the living scope

● Do all the necessary cleanup

● Do all the necessary cleanup
● Use WeakReference

private WeakReference<BigObject> bigObject;
public void execute() {
var ref = bigObject.get();
if (ref == null) {
ref = recreateBigObject();
bigObject = new WeakReference<>(ref);
}
ref.hello();
}

Ballance is the key
● Losing too much
● Performance costs
● Need to ﬁnd a balance

Let’s measure
Let’s analyze
Find the root cause
Fix it
Improve
Fix it
Prevent

void run() {
var plugins = List.of(new JavaPlugin(), new CPPPlugin());
plugins.forEach(Plugin::execute);
}

What can we do?
● Make Java plugin last?
● Add some cleanup between plugins
● Reduce the life of Plugin
● Maybe Queue is better than List here

void run() {
ArrayDeque<Plugin> plugins = ...
for (var plugin = plugins.poll(); plugin != null;
plugin = plugins.poll()) {
plugin.execute();
}
}

● Follow a “healthy diet”
● Monitor memory usage
● GC logs
● Perform stress testing
● Use VisualVm, memory
analyzer,...
● Add tests

Java Object Layout (JOL)
https://github.com/openjdk/jol

@Test
public void myTest() {
var big = new BigObject().new SmallObject();
Assert.assertTrue(
GraphLayout.parseInstance(big).totalCount() < MAX_SIZE);
}

A healthy diet for your Java application
● Avoid statics and mutability
● Clean ThreadLocals
● Free resources
● Avoid Non-static inner classes
● If still need them, be careful
● Reduce the scope of references
● Monitor memory usage

Useful links
● https://rules.sonarsource.com/
● https://owasp.org/www-community/vulnerabilities/Memory_leak
● https://www.baeldung.com/java-memory-leaks
● https://www.baeldung.com/java-static-ﬁelds-gc
● https://www.baeldung.com/java-weak-reference

Useful tools
● Visual VM : https://visualvm.github.io/
● Eclipse MAT : https://www.eclipse.org/mat/
● EqualsVeriﬁer : https://jqno.nl/equalsveriﬁer/
● Java Flight Recorder : https://docs.oracle.com/javacomponents/jmc-5-4/jfr-runtime-guide/about.htm#JFRUH173
● JOL : https://github.com/openjdk/jol
● Sonar : https://www.sonarsource.com/products/sonarqube/

A healthy diet for your Java application Devoxx France.pdf

More Related Content

Similar to A healthy diet for your Java application Devoxx France.pdf

Recently uploaded

A healthy diet for your Java application Devoxx France.pdf