• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
Introduction+To+Java+Concurrency
 

Introduction+To+Java+Concurrency

on

  • 1,378 views

 

Statistics

Views

Total Views
1,378
Views on SlideShare
1,368
Embed Views
10

Actions

Likes
0
Downloads
14
Comments
0

2 Embeds 10

http://www.frankappiah-tech.com 9
http://www.linkedin.com 1

Accessibility

Categories

Upload Details

Uploaded via as Adobe PDF

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    Introduction+To+Java+Concurrency Introduction+To+Java+Concurrency Presentation Transcript

    • JACCRA
    • http://frankappiahnsiah.wordpress.com Introduction to Java Concurrency Frank Appiah Software Developer Genkey Corp.
    • 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(); } Lock acquired private int getNewValue() { reentrantLock.lock(); value+=1; reentrantLock.unlock(); return value; Lock unacquired }
    • Different Implementation (edu.emory.mathcs.backport)  To use this implementation of Java Concurrency Just 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 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.
    • 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 Management ThreadPoolExecutor methods for management:  getTaskCount()  getCompletedTaskCount()  purge()  shutdown()  shutdownNow()
    • Further Reading  Tutorial  Download