SivaramaSundar.D

29th Nov 2012

Threading in Java

ConceptsWhen & Why do we need threadsThreads in javaConcurrency: Thread control &

SynchronizationConcurrency: Data management between

threadsBest practices: Threading the right way;Q&A

Processes A Process has a self-contained execution environment; an application, in general terms –

with own memory address space; with a main execution thread; which can own O/S resource handles – files, sockets etc.

1..* threads; Each process has one Main thread; System threads – GC, Object finalization, JVM housekeeping Timers and User created threads

Threads Execution unit – to execute a sequence of instructions Owns: Stack, Program Counter, Local variables Shares: Memory, Filehandles, Process States

ThreadGroups Grouping threads into a logical collection; Not used much.

ThreadPools A thread pool is a collection of threads set aside for a specific task; Ex: webserver thread

pool; saves thread creation overheads everytime; execute(Runnable command) Used for executing large numbers of asynchronous tasks provide a boundary mechanism to create and managing the resources within the pool Better thread management; Cleaner shutdown of threads; Ability to Add, Remove, Enumerate future tasks; Apt for a scheduler;

Concepts

Multitasking – Receive data via a socket & write to file(s)A Server handling multiple concurrent requests to serve

dataMake the UI more responsiveNumber crunching; Bulk data processing;Take advantage of multiprocessor systemsSimplify program logic when there are multiple

independent entitiesPerform blocking I/O without blocking the entire programEx:

A Webserver A real time device monitor to display device parameters A Monitoring application, polling multiple sources & providing

live updates

When & Why do we need threads?

When & Why do we need threads?

Threads in Java: Thread lifecycle

Runnable Interface & Thread Class, Daemon threads Instantiate the “Thread” Class with a “Runnable” implementation

(preferred way!) Subclass the “Thread” class & override the “run” method

Start – begin execution setDaemon – thread will be terminated

by VM during shutdown;

normal threads won’t; sleep

Sleeps are not precise; Sleep either in ms or ns The Sleep can be interrupted,

by other threads via the thread.interrupt call Yield (rarely used) - Relinquish control ;

during long running operations; Interrupt

Interrupts the wait state of the thread; invoked by the thread owner; Raises a InterruptedException

Threads in Java: Thread lifecycle

JoinMakes the calling thread wait until other thread completes;Typical usage: make sure all the child threads are terminated;Can be interrupted by the thread.interrupt call

waitNotify – Wakes up the thread waiting on the given object’s

monitornotifyAll – Wakes up all the threads waiting on the given

object’s monitorObselete methods

suspendresumeStop – use internal flags, join, wait & interrupt mechanisms

instead

Threads in Java: Thread lifecycle

Timers, TimerTask (Daemon)Schedule tasks (Runnable) for future execution in a

background thread. Tasks may be scheduled for one-time execution, or for repeated execution at regular intervals

Schedule (task, delay)ThreadFactory

Help create threads of a given type; subclassed threadsThreadInfo

Contains the information about a threadThreadReference

Object ref. with additional access to thread-specific information from the target VM. Provides access to internal stack frames, monitor references.

Threads in Java: Helper classes

Why Synchronization Prevent shared data corruption / thread interference / data integrity

Code Locks (Monitors)- Synchronized, Volatile

Each object in java has a unique monitor. When a synchronized method / block is invoked by the thread, the thread tries to take ownership of the monitor or block until it gets the ownership; The Thread acquires the monitor for the given object (ex:this / method, class object ref.). A monitor is automatically released when the method / block execution completes. Only one thread at a time

can own an object's monitor. Synchronized

Protect Code & Make data changes visible Block level Method level (uses intrinsic lock of the method’s object instance)

Volatile – bypass processer cache to use main memory One thread – One Lock – anytime Locks will be released in the event of any uncaught exceptions

Lock Interface for better control than “Synchronized” A single Lock can have multiple Conditions ReentrantLock – lock() ; Try... Finally{ unlock(); } ReentrantReadWriteLock - to get a read / write or both locks

Concurrency: Thread control & Synchronization

Concurrency: Thread control & Synchronization

DataSemaphores– Semaphore (Counting Semaphore)

acquire(), release()Mechanism to control access to a pool of shared resource,

between multiple processes, threadsActs like a gate – for a limited access pool / lift – with a fixed

capacity; some threads have to yield control, for the other threads to access the shared data;

While Locks are exclusive, semaphores are notOther examples:

Fixed no. of meeting rooms – with controlled accessMutexes – Same as a binary semaphore (lock - yes/no), but

across processesNormally mutexes has ownersTypical usage – to ensure single instance of an application /

process

Concurrency: Thread control & Synchronization

ThreadLocal<T> Provide Local variables for the thread (can be accessed only within this thread) Each thread holds an implicit reference to its copy of a thread-local variable as long as the

thread is alive When a thread dies; the thread local variables are subject to GC

Java.utils.concurrent ThreadPoolExecutor, ScheduledThreadPoolExecutor Java.util.Collections classes with built in support for handling concurrency & access from

multiple threads; uses collection segmentation & hence supports non-blocking – ex: the whole collection is not locked;

ConcurrentHashMap ConcurrentLinkedDeque ConcurrentLinkedQueue ConcurrentSkipListMap ConcurrentSkipListSet

Make normal collections thread safe via - java.util.Collections methods; blocking – ex: whole collection is locked;

SynchronousQueue SynchronizedCollection SynchronizedSet SynchronizedList SynchronizedMap SynchronizedSortedSet SynchronizedSortedMap

Concurrency: Data management between threads

DeadlockT1 -> W1; T1.DoSomething waits for W2.T2 -> W2; T2.DoSomething waits for W1.Hard to debug – but jConsole, jStack helps (demo

with jConsole); Simplify locks / avoid arbitrary synchronization

Race Condition A race condition occurs when 2 or more threads access shared

data and they try to change it at the same time; problems occur when one thread does a "check-then-act" and

another thread does something to the value in between the "check" and the "act“;tip: avoid ‘check & act’ situations when using threading;

Concurrency: Dead locks & Race Conditions

White-boarding & Brainstorming Document / Comment all threading code; Be Aware of the synchronized

keyword used as part of the method name – it is easy to miss if that a synchronized method uses an intrinsic lock; synchronized blocks are easier to spot;

Thorough Code Reviews Use locks judiciously – lock while writes Wait for spawned threads to complete, or force stop Exception handling – a thread will terminate on an unhandled exception

Make use of Thread.setDefaultUncaughtExceptionHandler -handler for all threads in the VMorsetUncaughtExceptionHandler(Thread.UncaughtExceptionHandler eh) - handler for

single specific thread Use immutable classes – Ex: String, Integer, BigDecimal, as they make

concurrency handling simple Know when JVM performs the synchronization for you: Static Initializer, final

fields, Creating objects before threads Avoid nested locks; to prevent deadlocks;

Best practices: Threading the right way;

Don't invoke methods on other objects while holding a lock. (Sounds crazy; ) Ensure that when you acquire multiple locks, you always acquire the locks in

the same order in all threads. Keep the synchronized blocks as short as possible; Don’t use blocking code inside a synchronized block – ex: Inputstream.read() Don’t tamper thread priorities; leave it to the JVM & O/S Avoid starvation of resources; Don’t code long running threads; Aids in debugging threading issues:

Thread.holdsLock (Object lockObj)- true if lock is held Thread.dumpStack() Inspect using Thread.State / getState() Provide a thread name when creating a thread Logs – with thread id’s; ThreadInfo class Threaddumps - Provide a stack trace of all running threads

(tool from jdk) jstack <pid> >> threaddumps.log (alternate) use jConsole to monitor the jvm & analyze stack trace of all live threads Using the “SendSignal.exe” to send a “break” signal to the process to get a thread dump

Best practices: Threading the right way;

Threading explained in simple terms- http://www.tutorialspoint.com/java/java_multithreading.htm

http://www.tutorialspoint.com/java/java_thread_synchronization.htm

http://www.tutorialspoint.com/java/java_multithreading.htm

http://www.tutorialspoint.com/java/java_thread_communication.htm

http://www.tutorialspoint.com/java/java_thread_deadlock.htm

Java Concurrency in Practice – Book – www.Jcip.net Hardcode multi-threading in java -

http://conferences.embarcadero.com/article/32141 Analyzing thread dumps-

http://www.javacodegeeks.com/2012/03/jvm-how-to-analyze-thread-dump.html

Links & thankful references to…

ThreadApp.java SimpleJavaThread.java

Deadlock.java A.java B.java

NewThread.java

SuspendResume.java

Pool.java

Code Examples

Q&A