Upload
frank-appiah
View
110
Download
0
Tags:
Embed Size (px)
DESCRIPTION
Citation preview
JACCRA
Frank AppiahSoftware Developer
Genkey Corp.
Introduction to Java Concurrency
http://frankappiahnsiah.wordpress.com
RoadMap Background Concept Demo
What is Java Concurrency ? Concurrency means existing or in operation at the same time
or together. Java provides : 1. Lock 2. Thread and Thread Management 3. Atomic It is in the package java.util.concurrency
RoadMap Background Concept Demo
LOCKS
Package: java.util.concurrent.locks
What are the locks in Java? Lock Lock implementations provide more extensive locking operations
than can be obtained using synchronized methods and statements. They allow more flexible structuring, may have quite different properties, and may support multiple associated Condition objects.
ReadWriteLock A ReadWriteLock maintains a pair of associated locks, one for
read-only operations and one for writing. The read lock may be held simultaneously by multiple reader threads, so long as there are no writers. The write lock is exclusive.
Lock A lock is a tool for controlling access to a shared resource by
multiple threads. Commonly, a lock provides exclusive access to a shared resource: only one thread at a time can acquire the lock and all access to the shared resource requires that the lock be acquired first. However, some locks may allow concurrent access to a shared resource, such as the read lock of a ReadWriteLock.
ReentrantLock A reentrant mutual exclusion Lock with the same basic
behavior and semantics as the implicit monitor lock accessed using synchronized methods and statements, but with extended capabilities.
Demo ReentrantLock reentrantLock=new ReentrantLock();
public int getNextSequenceID() { return getNewValue(); }
private int getNewValue() { reentrantLock.lock(); value+=1; reentrantLock.unlock(); return value; }
Lock acquired
Lock unacquired
Different Implementation(edu.emory.mathcs.backport)
To use this implementation of Java ConcurrencyJust append the package name below to all java.util.concurrent
package classes. edu.emory.mathcs.backport
Creating a Lock Factory with both implementations Check to see if edu.emory.mathcs.backport implementation
is available
static { try {
Class.forName("edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantLock");backportConcurrentPresent = true;
} catch (ClassNotFoundException ex) {backportConcurrentPresent = false;
}}
Creating a Lock Implementation
if (JdkVersion.getMajorJavaVersion() >= JdkVersion.JAVA_15) {
return new JdkConcurrentLock(timeoutSeconds);} else if (backportConcurrentPresent) {
return new BackportConcurrentLock(timeoutSeconds);
ATOMICS Package: java.util.concurrent.atomic
Uses It can be use as an atomic update flag (AtomicBoolean) use as a sequential atomic counter (AtomicInteger) use as an atomically incremented sequence
number(AtomicLong) use to hold an atomic reference to an object
(AtomicReference<V>,V is the reference object)
Demo
private AtomicLong atomic; public AtomicTest(long intialValue) { atomic=new AtomicLong(intialValue); }
public Long increment() { return atomic.incrementAndGet(); }
Concurrent Threads
Package: java.util.concurrent
What to look at? ThreadFactory ThreadPoolExecutor Callable (special form of Runnable class)
ThreadFactory Implement a custom thread factory
There is a single method called newThread that takes Runnable as its parameter
Purpose : To create a new thread for the ThreadPoolExecutor when a new work requires a thread.
public class CustomThreadFactory implements ThreadFactory
How to create a custom ThreadFactory?
public class CustomThreadFactory extends CustomThreadCreator implements ThreadFactory{
public CustomThreadFactory { super(); }
public CustomThreadFactory(String threadNamePrefix) { super(threadNamePrefix); }
public Thread newThread(Runnable r) {
return createThread(r); }
}
ThreadPoolExecutor It can be schedule or not For scheduled thread executor
use :ScheduledThreadPoolExecutor class. A custom thread pool executor may be preferable.
Demo Lets go to the code Walking through
Callable This just like Runnable but this returns a result of the
execution task. Call the submit method of ThreadPoolExecutor instance and
pass in the Callable interface implementation.
Thread ManagementThreadPoolExecutor methods for management: getTaskCount() getCompletedTaskCount() purge() shutdown() shutdownNow()
Further Reading Tutorial Download