Basics of Java Concurrency

Java Concurrency
Kishanthan Thangarajah
Senior Software Engineer

Agenda
o Why Concurrency?
o Processes and Threads
o Java Thread Example
o Thread Safety
o Race Conditions & Critical Sections
o Java Synchronization
o Deadlock, Starvation
o Java Concurrent APIs

Why Concurrency?
o Benefits
o Make use of multi processor system
o Handle asynchronous behaviour (eg : Server)
o Better responsive applications (eg : UI)

Why Concurrency?
o Risks
o Thread safety
o Deadlocks, starvation
o Performance overhead

Processes and Threads
o Process
o Runs independently of other processes and has
separate memory space.
o Thread
o Also runs independently of other threads, but
can access shared data of other threads in the
same process.
oA Java application at least has one thread
(main)

Java Thread Example
o Thread subclass
public class ExampleThread extends Thread {
@Override
public void run() {
System.out.println("Hello !!!");
}
}
ExampleThread thread = new ExampleThread();
thread.start();

Java Thread Example
o Implement “Runnable” interface
public class ExampleRunnable implements Runnable {
@Override
public void run() {
System.out.println("Hello !!!");
}
}
Thread thread = new Thread(new ExampleRunnable());
thread.start();

Java Thread Example
o Common mistake with threads
Calling run() instead of start()
This will not start a new thread, instead the run()
method will be executed by the same thread.

Java Thread Example
o Pausing a thread
Thread.sleep(5000);
Example : Cluster initialization
o Interrupting a thread
ExampleThread thread = new ExampleThread();
thread.start();
thread.interrupt();

Java Thread Example
othread.join() : wait on another thread for
completion
The join method allows one thread to wait for the
completion of another.

Java Thread Example
oThread Local
o used with variables that can only be accessed (read and
write) by the same thread.
public class ExampleThreadLocal {
public static class ExampleRunnable implements Runnable {
private ThreadLocal<Integer> threadLocal = new ThreadLocal<Integer>();
@Override
public void run() {
threadLocal.set((int) (Math.random() * 500));
System.out.println("Thread Local Variable Value : " + threadLocal.get());
}
}
public static void main(String[] args) {
ExampleRunnable runnable = new ExampleRunnable();
Thread t1 = new Thread(runnable);
Thread t2 = new Thread(runnable);
t1.start();
t2.start();
}
}

Java Thread Example
oThread Local
o Practical example : CarbonContext
oThread Signalling
o wait(), notify() and notifyAll()

Thread Safety
o If multiple threads access (read or write) the
same variable (or a code section) without
proper synchronization, the application is not
thread safe.
o Don't share mutable variable between
threads or make the variable immutable.
o Synchronize the access of the variable.

Race Condition & Critical Sections
o If two threads try to compete for same
resource and if the order in which the
resource is accessed is of interest, then there
arise a race condition.
oA resource (code section) that leads to race
conditions is called a critical section.

public class Example {
private int x = 0;
public void increment() {
x++;
}
}

o Single expression composed of multiple steps
- Thread Interference
o Inconsistence view of the value
- Memory consistency error

Java Synchronization
private int x = 0;
public synchronized void increment() {
x++;
}
public synchronized int getValue() {
return x;
}
}

o No two threads can execute synchronized
methods on the same object instance.
- Locks on objects.
o Changes to the object within synchronized
section are visible to all threads.
- Resumed threads will see the updated value

o The synchronized keyword can be used with the
following:
o Instance methods or code segment blocks
within instance methods
o Static methods or code segment blocks within
static methods

o Synchronized statements
synchronized (this) {
x++;
}
}

o Use of “static”
public static synchronized void sayHello1() {
System.out.println("Hello1 !!!");
}
public static void sayHello2() {
synchronized (Example.class) {
}
}
}

o Reentrant Synchronization
A thread can acquire lock already owned by it self.
public synchronized void sayHello1() {
sayHello2();
}
public void sayHello2() {
synchronized (this) {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
System.out.println("I was interrupted !!!");
}
}
}
}

Deadlock & Starvation
o Deadlock
o Two or more threads are blocked forever, waiting for each
other.
o Occur when multiple threads need the same locks, at the
same time, but obtain them in different order.
Thread 1 locks A, waits for B, Thread 2 locks B, waits for A
o Practical Example : Issue found with
CarbonDeploymentSchedulerTask and ClusterMessage
o Starvation
o A thread is not given regular access to CPU time (shared
resources) because of other threads.

Deadlock & Starvation
o Deadlock Prevention
o Order how the locks can be acquired
o Use locks instead of synchronized statements (fairness)

Java Concurrent APIs
o Found under java.util.concurrent
o High level concurrency objects
o Locks
o Executors
o Concurrent Collections
o Atomic variables

o Locks
Lock lock = …...
lock.lock();
try {
// critical section
} finally {
lock.unlock();
}

o ReentrantLock
o Provide reentrant behaviour, same as with
synchronized blocks, but with extended features (fairness).
public class LockExample {
private Lock lock = new ReentrantLock();
private int x = 0;
lock.lock();
try {
x++;
} finally {
lock.unlock();
}
}
}

o Read/Write Locks
o Used with the scenario where multiple readers present
with only one writer.
o Keeps a pair of locks, one for “read-only” operations
and one for writing
o Practical Example : TenantAxisUtils -> reading vs
terminating tenant axisConfigurations.

o Executors
o Thread creation and management itself is a separate
task when it comes to large scale applications.
o Three main categories
- Executor Service
- Thread Pools
- Fork/Join

o Executors Interfaces
1. ExecutorService, help manage lifecycle of the
individual tasks.
2. ScheduledExecutorService, supports periodic
execution of tasks.
o Practical example : CarbonDeploymentSchdularTask

o Thread Pool
o Manage a pool of worker threads.
o Reduces the overhead due to new thread
creation.
o Create thread pools using the factory methods
of java.util.concurrent.Executors.
o Example : Tomcat Listener Thread Pool,
Synapse Worker Thread pool

o Fork/Join
o From Java 7 onwards.
o Helps to take advantage of multi-processor
system.
o Break a large task into small tasks and execute
them parallelly
o Example : Count total number of prime
numbers between 1 to 1000.
o java.util.streams package uses implementation
of fork/join framework.

o Concurrent Collections
o Help avoid memory consistency errors
o ConcurrentMap
■Subinterface of Map with atomic map operations.
■Practical Example : Axis2 Deployer Map (uses
ConcurrentHashMap)
o Blocking Queue
■FIFO data structure that blocks or times out when
adding to a full queue, or get from an empty queue

o Atomic Variables
o Supports atomic operations on variables
o Practical Example : ClusterMessage on
Repository Update.
private AtomicInteger x = new AtomicInteger(0);
x.incrementAndGet();
}
public int getValue() {
return x.get();
}
}

Basics of Java Concurrency

More Related Content

What's hot

Viewers also liked

Similar to Basics of Java Concurrency

More from kshanth2101

Recently uploaded

Basics of Java Concurrency