4. 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
7. 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.
8. 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.
9. 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.
10. Demo
ReentrantLock reentrantLock=new ReentrantLock();
public int getNextSequenceID()
{
return getNewValue();
}
Lock acquired
private int getNewValue()
{
reentrantLock.lock();
value+=1;
reentrantLock.unlock();
return value; Lock unacquired
}
12. 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;
}
}
13. Creating a Lock Implementation
if (JdkVersion.getMajorJavaVersion() >= JdkVersion.JAVA_15) {
return new JdkConcurrentLock(timeoutSeconds);
} else if (backportConcurrentPresent) {
return new BackportConcurrentLock(timeoutSeconds);
15. 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)
16. Demo
private AtomicLong atomic;
public AtomicTest(long intialValue)
{
atomic=new AtomicLong(intialValue);
}
public Long increment()
{
return atomic.incrementAndGet();
}
18. What to look at?
ThreadFactory
ThreadPoolExecutor
Callable (special form of Runnable class)
19. ThreadFactory
Implement a custom thread factory
public class CustomThreadFactory implements ThreadFactory
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.
20. 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);
}
}
21. ThreadPoolExecutor
It can be schedule or not
For scheduled thread executor
use :ScheduledThreadPoolExecutor class.
A custom thread pool executor may be preferable.
23. 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.
