Java APIs- The missing manual (concurrency)

@HendrikEbbers
Karakun DevHub_
dev.karakun.com

@HendrikEbbers
JavaAPIsThe missing manual

Karakun DevHub_
@HendrikEbbersdev.karakun.com
About me
• Karakun Co-Founder
• Lead of JUG Dortmund
• JSR EG member
• JavaOne Rockstar, Java Champion
• JavaLand Programm Chair

Karakun DevHub_
About me

Karakun DevHub_
Executors
• Whenever code should be executed in parallel it gets
much harder… 
 
 
Let's write a simple http server in Java

Karakun DevHub_
Executors
public class HttpServer {
public static void main(String… args) {
while(true) {
HttpRequest request = getNextRequest();
request.sendResponse("Hello");
}
}
}

Karakun DevHub_
Executors
public class HttpServer {
while(true) {
HttpRequest request = getNextRequest();
}
}
}
returns the nextincoming request
sends response to client content of the response

Karakun DevHub_
Headline

Karakun DevHub_
Executors
• Let's test this with several users
• We can simulate this in Java 
 
• What will happen?
URL url = new URL("http://localhost:8080/hello"); 
System.out.println(IOUtils.toString(url.openStream()));

Karakun DevHub_
Executors
• We can't use a single threaded approach here
• The handling must work in parallel.
• Let's have a look on a solution that is based on the
Thread class

Karakun DevHub_
Executors
while(true) {
final HttpRequest request = getNextRequest();
Runnable r = () -> {
}
new Thread(r).start();
}
}

Karakun DevHub_
Service Provider Interface
• Only the "Application" module knows all
implementations since it's the only module that
depends on all other modules
That was easy, bro!

Karakun DevHub_
Executors
• The server is working much better
• But we lost control:
• How many threads are running?

Karakun DevHub_
Executors
But the biggest question is:
How many threads
can we run in Java?

Karakun DevHub_
Executors

Karakun DevHub_
Executors
• Using the old school Thread class seams to be a
bad idea
• Let's try to use some modern Java concurrency
classes
the java.util.concurrent package

Karakun DevHub_
Executors
• To execute tasks in a background thread Java
provides the Executor interface
• Instances can be created by using the factory
methods of the Executors class

Karakun DevHub_
Executors
Executor myExecutor = Executors.newSingleThreadExecutor();
Runnable r = () -> doSomeAction();
myExecutor.execute(r);
Creates an executer
Runnable will be
executed in a thread.
method call do not block

Karakun DevHub_
Executors
Executor myExecutor = Executors.newSingleThreadExecutor();
Executor myExecutor = Executors.newFixedThreadPool(5);
Wraps one thread
Wraps 5 threads

Karakun DevHub_
Executors
• Executor instances can easily be reused.
• No need to create a new one for each call.

Karakun DevHub_
Executors
• Different behavior based on the given Executor
for(int i = 0; i < 100; i++) {
final Runnable r = () -> {
sleep(2_000);
print("Moin");
}
executor.execute(r);
}

Karakun DevHub_
Executors
Let me introduce you the
CELEBRITY
EXECUTOR

Karakun DevHub_
Executors
• No speciﬁc thread count deﬁned
• Threads will be created and destroyed based on the
work load
• Threads will be reused
Executor myExecutor = Executors.newCachedThreadPool();

Karakun DevHub_
Executors
final Executor executor = Executors.newCachedThreadPool();
while(true) {
final HttpRequest request = getNextRequest();
final Runnable r = () -> {
}
executor.execute(r);
}
}

Karakun DevHub_
Executors
• We said that we do not want to use the Thread
class anymore.
• All types are based on threads…
• And we can conﬁgure them…
• So let's use Thread again

Karakun DevHub_
Executors
• A custom thread factory can be used to create an
executor
• Thread factory can conﬁgure the internal threads
ThreadFactory tf = . . .
Executor myExecutor = Executors.newCachedThreadPool(tf);

Karakun DevHub_
Executors
public class MyThreadFactory implements ThreadFactory { 
 
final AtomicLong counter = new AtomicLong(0); 
 
@Override 
public Thread newThread(Runnable r) { 
final Thread thread = new Thread(); 
thread.setName("My private thread " + counter.incrementAndGet()); 
thread.setUncaughtExceptionHandler((t, e) -> {
System.out.println("BOOOOOOM!");
}); 
return thread; 
} 
}

Karakun DevHub_
Executors
But wait!
the factory returns
ExecutorService
and not
Executor
instances

Karakun DevHub_
Headline
• ExecutorService provides a lot of
new functionality.
• We will handle this in a separate
chapter

Karakun DevHub_
Synchronization
• Let's start this chapter with a simple class
• Only a wrapper for a list
• What could go wrong…

Karakun DevHub_
Synchronization
public class Holder {
private final List<String> data = new ArrayList<>();
public void add(String v) {this.data.add(v);}
public void remove(String v) {this.data.remove(v);}
public void forEach(Consumer c) { data.forEach(c);}
}

Karakun DevHub_
Synchronization
add("A");
add("B");
add("C");
add("D");
add("E");
add("F");
add("G");
add("H");
remove("1");
remove("2");
remove("3");
remove("4");
remove("5");
remove("6");
remove("7");
remove("8");
forEach(. . .);
forEach(. . .);
forEach(. . .);
forEach(. . .);
forEach(. . .);
forEach(. . .);
forEach(. . .);
forEach(. . .);
User A User B User C

Karakun DevHub_
Synchronization
add("A");
add("B");
add("C");
add("D");
add("E");
add("F");
add("G");
add("H");
remove("1");
remove("2");
remove("3");
remove("4");
remove("5");
remove("6");
remove("7");
remove("8");
forEach(. . .);
forEach(. . .);
forEach(. . .);
forEach(. . .);
forEach(. . .);
forEach(. . .);
forEach(. . .);
forEach(. . .);
User A User B User C
Thread Thread Thread

Karakun DevHub_
Synchronization
ConcurrentModificationException

Karakun DevHub_
Synchronization
• Java provides a keyword that deﬁnes synchronized
access for such use cases
Do you know The Keyword?

Karakun DevHub_
synchronized
public synchronized void add(String v) {. . .}
public synchronized void remove(String v) {. . .}
public synchronized void forEach(Consumer c) {. . .}
}

Karakun DevHub_
synchronized
add("A");
add("B");
add("C");
remove("1");
remove("2");
remove("3");
forEach(. . .);
forEach(. . .);
wait
wait
wait
wait

Karakun DevHub_
synchronized
• The synchronized keyword provides thread
synchronization
• Internally Java provides a monitor lock
• Each monitor is bound to an object
• Java provides several ways how the
synchronized keyword can be used

Karakun DevHub_
synchronized
public synchronized void add(String v) {. . .}
}
Lock is based on this (the
object instance)

Karakun DevHub_
synchronized
final Holder a = new Holder();
final Holder b = new Holder();
doSomeParallelStuff(a, b);
No synchronization between
instance a and B

Karakun DevHub_
synchronized
public static synchronized void myMethod() {. . .}
}
Lock is based on the
Holder class

Karakun DevHub_
synchronized
• The synchronized keyword provides reentrant
functionality
• A lock is always bound to the current thread
• A thread can acquire the same lock several times
• Helps to avoid deadlocks

Karakun DevHub_
synchronized
public synchronized void myMethod() {
myOtherMethod();
}
public synchronized void myOtherMethod() {
//TODO: add code
}
}

Karakun DevHub_
synchronized
• Using synchronized can create some problems
• Think about using synchronized in a base class and
derived classes
• Ends in implicit synchronization dependencies
• Can end in deadlocks

Karakun DevHub_
synchronized
private final List<String> l = new ArrayList();
public synchronized void add(String v) {l.add(v);}
public synchronized void remove(String v) {l.remove(v);}
}

Karakun DevHub_
synchronized
public class MyHolder extends Holder {
private final List<Integer> l = new ArrayList();
public synchronized void addInt(int v) {l.add(v);}
}
It is not possible to call
the 2 add methods in
parallel

Karakun DevHub_
synchronized
public class MyHolder extends Holder {
private final List<Integer> l = new ArrayList();
public synchronized void run() {
while(true) {
sleep(1000);
printTime();
}
}
}
Once this is called all
synchronised methods form
Holder class are useless…

Karakun DevHub_
synchronized
• Try to use synchronized by specifying a private
monitor object
• To do so synchronized can be used as a block
statement
• Derived classes can not access the monitor object

Karakun DevHub_
synchronized
private final Object monitor = new Object();
public void myMethod() {
synchronized(monitor) {
//TODO: add code
}
}
}
Internal Code of the block
is synchronized.
Lock is based on monitor
object / instance

Karakun DevHub_
synchronized
• Since synchronized is a Java keyword it is
compiled in speciﬁed byte code instructions
• Instructions called MonitorEnter and
MonitorExit

Karakun DevHub_
Lock
• Since Java 1.5 we can use a Java API for
synchronization
• Against the synchronized keyword we have all the
beneﬁts of an API
• See java.util.concurrent.locks.Lock

Karakun DevHub_
Lock
private final List<String> listA;
private final Lock listLockA;
private final List<String> listB;
private final Lock listLockB;
}
Just define a lock instance
for each Monitor that
should be synchronized

Karakun DevHub_
Lock
• Use ReentrantLock as concrete type
private final Lock listLockA = new ReentrantLock();
Same behavior as synchronized

Karakun DevHub_
Lock
• A Lock controls access to a shared resource by
multiple threads
• The most important methods of a Lock are lock()
and unlock()
• This method deﬁnes exclusive access to a resource

Karakun DevHub_
Lock
• By calling lock() the resource will be locked by the
current thread
• By calling unlock() the current thread can ﬁnish
the exclusive locking of the resource
• Calling lock() will block the current thread until no
other thread has an exclusive lock

Karakun DevHub_
Lock
public void addToA(final String v) {
listLockA.lock();
getListA().add(v);
listLockA.unlock();
}

Karakun DevHub_
Lock
public void addToA(String v) {
listLockA.lock();
getListA().add(v);
listLockA.unlock();
}

Karakun DevHub_
Lock
listLockA.lock();
getListA().add(v);
listLockA.unlock();
}
Exception

Karakun DevHub_
Lock
• NEVER, NEVER, NEVER USE LOCK WITHOUT
TRY-FINAL
lock.lock();
try {
//access resource
} finally {
lock.unlock();
}

Karakun DevHub_
Lock
listLockA.lock();
try {
getListA().add(v);
} finally {
listLockA.unlock();
}
}

Karakun DevHub_
Lock
• Even more complexe use cases are supported by
the Lock API.
• Use tryLock() to not block threads.
• Create a Condition for monitor functionality.
Will be handled in a
separate topic

Karakun DevHub_
Other solutions
• By the way the complete problem could be handled
in a different way: 
• Java provides some special collection types to get
rid of ConcurrentModiﬁcationException:
Will be handled in a
separate topic
private final List<String> listA = new ArrayList<>();
List<String> listA = new CopyOneWriteArrayList<>();

@HendrikEbbers
• Check our website for developers 
• Subscribe to our newsletter 
• Join us
dev.karakun.com | @HendrikEbbers
Karakun DevHub_
dev.karakun.com
https://dev.karakun.com
https://dev.karakun.com/subscribe/
https://dev.karakun.com/you-at-karakun/

Java APIs- The missing manual (concurrency)

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Java APIs- The missing manual (concurrency)

Similar to Java APIs- The missing manual (concurrency) (20)

More from Hendrik Ebbers

More from Hendrik Ebbers (20)

Recently uploaded

Recently uploaded (20)

Java APIs- The missing manual (concurrency)