SlideShare une entreprise Scribd logo
1  sur  51
Télécharger pour lire hors ligne
Programming Paradigms
• Single Process
• Multi Process
• Multi Core/Multi Thread
Multi Core CPU
Process
• Process
A process runs independently and isolated of
other processes. It cannot directly access
shared data in other processes. The resources
of the process are allocated to it via the
operating system, e.g. memory and CPU time.
Java Process
Objects
• ADTs, aggregate components, JavaBeans, monitors,
business objects, remote RMI objects, subsystems, ...
• May be grouped according to structure, role, ...
• Usable across multiple activities — focus on SAFETY
Activities
• Messages, call chains, threads, sessions, scenarios,
scripts, workflows, use cases, transactions, data flows,
mobile computations
Thread
• Threads are so called lightweight processes
which have their own call stack but an access
shared data. Every thread has its own memory
cache. If a thread reads shared data it stores
this data in its own memory cache. A thread
can re-read the shared data
What is The Gain
• Amdahl's Law
• It states that a small portion of the program which
cannot be parallelized will limit the overall speed-up
available from parallelization.
• A program solving a large mathematical or engineering
problem will typically consist of several parallelizable
parts and several non-parallelizable (sequential) parts.
If p is the fraction of running time a sequential program
spends on non-parallelizable parts, then
• S = 1/p
How much is the speed up
• If the sequential portion of a program accounts
for 10% of the runtime, we can get no more than
a 10× speed-up, regardless of how many
processors are added. This puts an upper limit on
the usefulness of adding more parallel execution
units. "When a task cannot be partitioned
because of sequential constraints, the application
of more effort has no effect on the schedule. The
bearing of a child takes nine months, no matter
how many women are assigned
How does Java help to Parallel
Programming
• Has Threads since its inception
• Threads have their own stack. But uses heap
of the JVM
• Has many constructs to control the
concurrency
• Programmer knowledge is very critical
JVM Process Heap
Thread Class
Constructors
• Thread(Runnable r) constructs so run() calls r.run()
• — Other versions allow names, ThreadGroup placement
Principal methods
• start() activates run() then returns to caller
• isAlive() returns true if started but not stopped
• join() waits for termination (optional timeout)
• interrupt() breaks out of wait, sleep, or join
• isInterrupted() returns interruption state
• getPriority() returns current scheduling priority
• setPriority(int priorityFromONEtoTEN) sets it
How to Implement a Thread
• Subclass Thread. The Thread class itself
implements Runnable, though its run method
does nothing. An application can subclass
Thread, providing its own implementation of
run
Thread Subclass
public class HelloThread extends Thread {
public void run() {
System.out.println("Hello from a thread!");
}
public static void main(String args[]) {
(new HelloThread()).start();
}
}
Implement Runnable Interface
public class HelloRunnable implements Runnable
{
public void run() {
System.out.println("Hello from a thread!"); }
public static void main(String args[]) {
(new HelloRunnable()).start();
}
}
Pausing while executing
• Thread.sleep causes the current thread to
suspend execution for a specified period.
• This is an efficient means of making processor
time available to the other threads of an
application or other applications that might be
running on a computer system. The sleep
method can also be used for pacing
Thread Management
• To directly control thread creation and
management, simply instantiate Thread each
time the application needs to initiate an
asynchronous task.
• To abstract thread management from the rest
of your application, pass the application's
tasks to an executor.
Sleep Example
• main declares that it throws
InterruptedException. This is an exception that
sleep throws when another thread interrupts
the current thread while sleep is active. Since
this application has not defined another
thread to cause the interrupt, it doesn't
bother to catch InterruptedException.
Communicating with Thread
• Interrupts
• An interrupt is an indication to a thread that it
should stop what it is doing and do something
else. It's up to the programmer to decide
exactly how a thread responds to an interrupt,
but it is very common for the thread to
terminate. This is the usage emphasized in this
lesson.
Interrupt requirement
• A thread sends an interrupt by invoking
interrupt on the Thread object for the thread
to be interrupted. For the interrupt
mechanism to work correctly, the interrupted
thread must support its own interruption.
Interrupt Status
• The interrupt mechanism is implemented
using an internal flag known as the interrupt
status. Invoking Thread.interrupt sets this flag.
When a thread checks for an interrupt by
invoking the static method
Thread.interrupted, interrupt status is cleared.
The non-static isInterrupted method, which is
used by one thread to query the interrupt
status of another, does not change the
interrupt status flag.
Interrupted Exception and Status
• By convention, any method that exits by
throwing an InterruptedException clears
interrupt status when it does so. However, it's
always possible that interrupt status will
immediately be set again, by another thread
invoking interrupt.
Thread Collaboration
• The join method allows one thread to wait for the
completion of another. If t is a Thread object whose
thread is currently executing,
• t.join();
• causes the current thread to pause execution until t's
thread terminates. Overloads of join allow the
programmer to specify a waiting period. However, as
with sleep, join is dependent on the OS for timing, so
you should not assume that join will wait exactly as
long as you specify.
• Like sleep, join responds to an interrupt by exiting with
an InterruptedException.
Thread Interruption Example
Synchronization
• Threads communicate primarily by sharing
access to fields and the objects reference
fields refer to. This form of communication is
extremely efficient, but makes two kinds of
errors possible: thread interference and
memory consistency errors. The tool needed
to prevent these errors is synchronization.
Synchronization Mechanisms
• Thread Interference describes how errors are introduced
when multiple threads access shared data.
• Memory Consistency Errors describes errors that result
from inconsistent views of shared memory.
• Synchronized Methods describes a simple idiom that can
effectively prevent thread interference and memory
consistency errors.
• Implicit Locks and Synchronization describes a more
general synchronization idiom, and describes how
synchronization is based on implicit locks.
• Atomic Access talks about the general idea of operations
that can't be interfered with by other threads.
Synchronization Libraries
Semaphores
Maintain count of the number of threads allowed to pass
Latches
Boolean conditions that are set once, ever
Barriers
Counters that cause all threads to wait until all have
finished
Reentrant Locks
Java-style locks allowing multiple acquisition by same
thread, but that may be acquired and released as needed
Mutexes
Non-reentrant locks
Read/Write Locks
Pairs of conditions in which the readLock may be shared,
but the writeLock is exclusive
Semaphores
Conceptually serve as permit holders
• Construct with an initial number of permits (usually 0)
• require waits for a permit to be available, then takes one
• release adds a permit But in normal implementations, no actual
permits change hands.
• The semaphore just maintains the current count.
• Enables very efficient implementation
Applications
• Isolating wait sets in buffers, resource controllers
• Designs that would otherwise encounter missed signals
— Where one thread signals before the other has even
started waiting
— Semaphores ‘remember’ how many times they were signalled
Counter Using Semaphores
class BoundedCounterUsingSemaphores {
long count_ = MIN;
Sync decPermits_= new Semaphore(0);
Sync incPermits_= new Semaphore(MAX-MIN);
synchronized long value() { return count_; }
void inc() throws InterruptedException {
incPermits_.acquire();
synchronized(this) { ++count_; }
decPermits_.release();
}
void dec() throws InterruptedException {
decPermits_.acquire();
synchronized(this) { --count_; }
incPermits_.release();
}
}
Using Latches
• Conditions starting out false, but once set
true, remain true forever
• Initialization flags
• End-of-stream conditions
• Thread termination
• Event occurrence
Using Barrier Conditions
Count-based latches
• Initialize with a fixed count
• Each release monotonically decrements count
• All acquires pass when count reaches zero
Liveness
• A concurrent application's ability to execute in
a timely manner is known as its liveness. This
section describes the most common kind of
liveness problem, deadlock, and goes on to
briefly describe two other liveness problems,
starvation and livelock.
Deadlock
• Deadlock describes a situation where two or
more threads are blocked forever, waiting for
each other. Here's an example.
• Alphonse and Gaston are friends, and great
believers in courtesy. A strict rule of courtesy is
that when you bow to a friend, you must remain
bowed until your friend has a chance to return
the bow. Unfortunately, this rule does not
account for the possibility that two friends might
bow to each other at the same time.
Starvation and Livelock
• Starvation describes a situation where a thread is
unable to gain regular access to shared resources
and is unable to make progress. This happens
when shared resources are made unavailable for
long periods by "greedy" threads.
• A thread often acts in response to the action of
another thread. If the other thread's action is also
a response to the action of another thread, then
livelock may result.
Guarded Blocks
• Threads often have to coordinate their
actions. The most common coordination idiom
is the guarded block. Such a block begins by
polling a condition that must be true before
the block can proceed. There are a number of
steps to follow in order to do this correctly.
Guarded Block (cont..)
• Constant polling for Condition
• Use wait/notify method
• Immutable Objects
• Producer Consumer Example
• A Synchronized Class Example
Immutable Object
1. Don't provide "setter" methods — methods that modify fields or
objects referred to by fields.
2. Make all fields final and private.
3. Don't allow subclasses to override methods. The simplest way to
do this is to declare the class as final. A more sophisticated
approach is to make the constructor private and construct
instances in factory methods.
4. If the instance fields include references to mutable objects, don't
allow those objects to be changed:
– Don't provide methods that modify the mutable objects.
– Don't share references to the mutable objects. Never store
references to external, mutable objects passed to the constructor; if
necessary, create copies, and store references to the copies.
Similarly, create copies of your internal mutable objects when
necessary to avoid returning the originals in your methods.
High Level Concurrency Objects
• Lock objects support locking idioms that simplify many
concurrent applications.
• Executors define a high-level API for launching and
managing threads. Executor implementations provided by
java.util.concurrent provide thread pool management
suitable for large-scale applications.
• Concurrent collections make it easier to manage large
collections of data, and can greatly reduce the need for
synchronization.
• Atomic variables have features that minimize
synchronization and help avoid memory consistency errors.
• ThreadLocalRandom (in JDK 7) provides efficient generation
of pseudorandom numbers from multiple threads.
Lock Objects
• Only one thread can own a implicit Lock object at a
time. Lock objects also support a wait/notify
mechanism, through their associated Condition
objects.
• The biggest advantage of Lock objects over implicit
locks is their ability to back out of an attempt to
acquire a lock. The tryLock method backs out if the
lock is not available immediately or before a timeout
expires (if specified). The lockInterruptibly method
backs out if another thread sends an interrupt before
the lock is acquired.
Locks Illustration
Executors
• In large-scale applications, it makes sense to
separate thread management and creation from
the rest of the application. Objects that
encapsulate these functions are known as
executors.
• Executor Interfaces define the three executor
object types.
• Thread Pools are the most common kind of
executor implementation.
• Fork/Join is a framework (new in JDK 7) for taking
advantage of multiple processors.
Executor Interfaces
• The java.util.concurrent package defines three
executor interfaces:
• Executor, a simple interface that supports
launching new tasks.
• ExecutorService, a subinterface of Executor,
which adds features that help manage the
lifecycle, both of the individual tasks and of the
executor itself.
• ScheduledExecutorService, a subinterface of
ExecutorService, supports future and/or periodic
execution of tasks.
The Executor Interface
• The Executor interface provides a single
method, execute, designed to be a drop-in
replacement for a common thread-creation
idiom. If r is a Runnable object, and e is an
Executor object you can replace
• (new Thread(r)).start();
• with
• e.execute(r);
The ExecutorService Interface
• The ExecutorService interface supplements execute with
a similar, but more versatile submit method. Like
execute, submit accepts Runnable objects, but also
accepts Callable objects, which allow the task to return a
value. The submit method returns a Future object, which
is used to retrieve the Callable return value and to
manage the status of both Callable and Runnable tasks.
• ExecutorService also provides methods for submitting
large collections of Callable objects. Finally,
ExecutorService provides a number of methods for
managing the shutdown of the executor. To support
immediate shutdown, tasks should handle interrupts
correctly.
The ScheduledExecutorService
Interface
• The ScheduledExecutorService interface
supplements the methods of its parent
ExecutorService with schedule, which
executes a Runnable or Callable task after a
specified delay. In addition, the interface
defines scheduleAtFixedRate and
scheduleWithFixedDelay, which executes
specified tasks repeatedly, at defined intervals.
Thread Pools
• Using worker threads minimizes the overhead
due to thread creation. Thread objects use a
significant amount of memory, and in a large-
scale application, allocating and deallocating
many thread objects creates a significant
memory management overhead.
• Tasks are submitted to the pool via an internal
queue, which holds extra tasks whenever
there are more active tasks than threads.
Thread Pools
• newFixedThreadPool
• newCachedThreadPool
• newSingleThreadExecutor
• For customized needs one can construct
• java.util.concurrent.ThreadPoolExecutor or
java.util.concurrent.ScheduledThreadPoolExec
utor
Fork/Join
• The fork/join framework is an implementation
of the ExecutorService interface that helps you
take advantage of multiple processors. It is
designed for work that can be broken into
smaller pieces recursively. The goal is to use all
the available processing power to enhance the
performance of your application.
Basic Use
• if (my portion of the work is small enough)
– do the work directly
• else
– split my work into two pieces
– invoke the two pieces and wait for the results
• After your ForkJoinTask is ready, create one that
represents all the work to be done and pass it to
the invoke() method of a ForkJoinPool instance.
Concurrent Collections
• The java.util.concurrent package includes a
number of additions to the Java Collections
Framework
• BlockingQueue
• ConcurrentMap
• ConcurrentSkipList
• All of these collections help avoid Memory
Consistency Errors by defining a happens-before
relationship between an operation that adds an
object to the collection with subsequent
operations that access or remove that object.
Atomic Variables
• The java.util.concurrent.atomic package
defines classes that support atomic operations
on single variables. All classes have get and set
methods that work like reads and writes on
volatile variables.
Concurrent Random Numbers
• In JDK 7, java.util.concurrent includes a
convenience class, ThreadLocalRandom, for
applications that expect to use random
numbers from multiple threads or
ForkJoinTasks.
• int r = ThreadLocalRandom.current()
.nextInt(4, 77);
Designing Objects for
Concurrency
Patterns for safely representing and managing state
Immutability
• Avoiding interference by avoiding change
Locking
• Guaranteeing exclusive access
State dependence
• What to do when you can’t do anything
Containment
• Hiding internal objects
Splitting
• Separating independent aspects of objects and locks

Contenu connexe

Tendances

MULTI THREADING IN JAVA
MULTI THREADING IN JAVAMULTI THREADING IN JAVA
MULTI THREADING IN JAVAVINOTH R
 
Java And Multithreading
Java And MultithreadingJava And Multithreading
Java And MultithreadingShraddha
 
Multithreading in java
Multithreading in javaMultithreading in java
Multithreading in javaArafat Hossan
 
Java Multithreading Using Executors Framework
Java Multithreading Using Executors FrameworkJava Multithreading Using Executors Framework
Java Multithreading Using Executors FrameworkArun Mehra
 
Identifying classes and objects ooad
Identifying classes and objects ooadIdentifying classes and objects ooad
Identifying classes and objects ooadMelba Rosalind
 
Polymorphism in java
Polymorphism in javaPolymorphism in java
Polymorphism in javasureshraj43
 
Java Multithreading
Java MultithreadingJava Multithreading
Java MultithreadingRajkattamuri
 
Synchronization.37
Synchronization.37Synchronization.37
Synchronization.37myrajendra
 
Multithreading
MultithreadingMultithreading
MultithreadingA B Shinde
 
Processes and Processors in Distributed Systems
Processes and Processors in Distributed SystemsProcesses and Processors in Distributed Systems
Processes and Processors in Distributed SystemsDr Sandeep Kumar Poonia
 
Ch 3 event driven programming
Ch 3 event driven programmingCh 3 event driven programming
Ch 3 event driven programmingChaffey College
 

Tendances (20)

Thread
ThreadThread
Thread
 
Pthread
PthreadPthread
Pthread
 
Threads .ppt
Threads .pptThreads .ppt
Threads .ppt
 
MULTI THREADING IN JAVA
MULTI THREADING IN JAVAMULTI THREADING IN JAVA
MULTI THREADING IN JAVA
 
Interface
InterfaceInterface
Interface
 
Java And Multithreading
Java And MultithreadingJava And Multithreading
Java And Multithreading
 
Multithreading in java
Multithreading in javaMultithreading in java
Multithreading in java
 
Java Multithreading Using Executors Framework
Java Multithreading Using Executors FrameworkJava Multithreading Using Executors Framework
Java Multithreading Using Executors Framework
 
Java annotations
Java annotationsJava annotations
Java annotations
 
Identifying classes and objects ooad
Identifying classes and objects ooadIdentifying classes and objects ooad
Identifying classes and objects ooad
 
Polymorphism in java
Polymorphism in javaPolymorphism in java
Polymorphism in java
 
Java Multithreading
Java MultithreadingJava Multithreading
Java Multithreading
 
C# Thread synchronization
C# Thread synchronizationC# Thread synchronization
C# Thread synchronization
 
java swing
java swingjava swing
java swing
 
Synchronization.37
Synchronization.37Synchronization.37
Synchronization.37
 
Spring annotation
Spring annotationSpring annotation
Spring annotation
 
Multithreading
MultithreadingMultithreading
Multithreading
 
Processes and Processors in Distributed Systems
Processes and Processors in Distributed SystemsProcesses and Processors in Distributed Systems
Processes and Processors in Distributed Systems
 
Ch 3 event driven programming
Ch 3 event driven programmingCh 3 event driven programming
Ch 3 event driven programming
 
Presentation1
Presentation1Presentation1
Presentation1
 

En vedette

Clean Lambdas & Streams in Java8
Clean Lambdas & Streams in Java8Clean Lambdas & Streams in Java8
Clean Lambdas & Streams in Java8Victor Rentea
 
Functional Java 8 in everyday life
Functional Java 8 in everyday lifeFunctional Java 8 in everyday life
Functional Java 8 in everyday lifeAndrea Iacono
 
Java8 training - class 3
Java8 training - class 3Java8 training - class 3
Java8 training - class 3Marut Singh
 
Java8 training - Class 1
Java8 training  - Class 1Java8 training  - Class 1
Java8 training - Class 1Marut Singh
 
Java8 training - class 2
Java8 training - class 2Java8 training - class 2
Java8 training - class 2Marut Singh
 
Building Applications with a Graph Database
Building Applications with a Graph DatabaseBuilding Applications with a Graph Database
Building Applications with a Graph DatabaseTobias Lindaaker
 
Jumping-with-java8
Jumping-with-java8Jumping-with-java8
Jumping-with-java8Dhaval Dalal
 
Java Hands-On Workshop
Java Hands-On WorkshopJava Hands-On Workshop
Java Hands-On WorkshopArpit Poladia
 
Concurrency & Parallel Programming
Concurrency & Parallel ProgrammingConcurrency & Parallel Programming
Concurrency & Parallel ProgrammingRamazan AYYILDIZ
 
Java day2016 "Reinventing design patterns with java 8"
Java day2016 "Reinventing design patterns with java 8"Java day2016 "Reinventing design patterns with java 8"
Java day2016 "Reinventing design patterns with java 8"Alexander Pashynskiy
 
Why Transcriptome? Why RNA-Seq? ENCODE answers….
Why Transcriptome? Why RNA-Seq?  ENCODE answers….Why Transcriptome? Why RNA-Seq?  ENCODE answers….
Why Transcriptome? Why RNA-Seq? ENCODE answers….Mohammad Hossein Banabazi
 
Java Concurrency, Memory Model, and Trends
Java Concurrency, Memory Model, and TrendsJava Concurrency, Memory Model, and Trends
Java Concurrency, Memory Model, and TrendsCarol McDonald
 
Java Multithreading and Concurrency
Java Multithreading and ConcurrencyJava Multithreading and Concurrency
Java Multithreading and ConcurrencyRajesh Ananda Kumar
 
Java Concurrency in Practice
Java Concurrency in PracticeJava Concurrency in Practice
Java Concurrency in PracticeAlina Dolgikh
 
Working With Concurrency In Java 8
Working With Concurrency In Java 8Working With Concurrency In Java 8
Working With Concurrency In Java 8Heartin Jacob
 

En vedette (20)

Clean Lambdas & Streams in Java8
Clean Lambdas & Streams in Java8Clean Lambdas & Streams in Java8
Clean Lambdas & Streams in Java8
 
Functional Java 8 in everyday life
Functional Java 8 in everyday lifeFunctional Java 8 in everyday life
Functional Java 8 in everyday life
 
Java8 training - class 3
Java8 training - class 3Java8 training - class 3
Java8 training - class 3
 
Java8 training - Class 1
Java8 training  - Class 1Java8 training  - Class 1
Java8 training - Class 1
 
Java8 training - class 2
Java8 training - class 2Java8 training - class 2
Java8 training - class 2
 
Building Applications with a Graph Database
Building Applications with a Graph DatabaseBuilding Applications with a Graph Database
Building Applications with a Graph Database
 
What is concurrency
What is concurrencyWhat is concurrency
What is concurrency
 
Java8
Java8Java8
Java8
 
Jumping-with-java8
Jumping-with-java8Jumping-with-java8
Jumping-with-java8
 
Apache camel
Apache camelApache camel
Apache camel
 
Java Hands-On Workshop
Java Hands-On WorkshopJava Hands-On Workshop
Java Hands-On Workshop
 
Concurrency & Parallel Programming
Concurrency & Parallel ProgrammingConcurrency & Parallel Programming
Concurrency & Parallel Programming
 
Java day2016 "Reinventing design patterns with java 8"
Java day2016 "Reinventing design patterns with java 8"Java day2016 "Reinventing design patterns with java 8"
Java day2016 "Reinventing design patterns with java 8"
 
Why Transcriptome? Why RNA-Seq? ENCODE answers….
Why Transcriptome? Why RNA-Seq?  ENCODE answers….Why Transcriptome? Why RNA-Seq?  ENCODE answers….
Why Transcriptome? Why RNA-Seq? ENCODE answers….
 
AngularJS2
AngularJS2AngularJS2
AngularJS2
 
Java Concurrency, Memory Model, and Trends
Java Concurrency, Memory Model, and TrendsJava Concurrency, Memory Model, and Trends
Java Concurrency, Memory Model, and Trends
 
Java Multithreading and Concurrency
Java Multithreading and ConcurrencyJava Multithreading and Concurrency
Java Multithreading and Concurrency
 
Concurrency
ConcurrencyConcurrency
Concurrency
 
Java Concurrency in Practice
Java Concurrency in PracticeJava Concurrency in Practice
Java Concurrency in Practice
 
Working With Concurrency In Java 8
Working With Concurrency In Java 8Working With Concurrency In Java 8
Working With Concurrency In Java 8
 

Similaire à Concurrency with java

Concurrency Programming in Java - 05 - Processes and Threads, Thread Objects,...
Concurrency Programming in Java - 05 - Processes and Threads, Thread Objects,...Concurrency Programming in Java - 05 - Processes and Threads, Thread Objects,...
Concurrency Programming in Java - 05 - Processes and Threads, Thread Objects,...Sachintha Gunasena
 
Java multithreading
Java multithreadingJava multithreading
Java multithreadingMohammed625
 
Multithreading
MultithreadingMultithreading
MultithreadingF K
 
8.-OBJECT-ORIENTED-PROGRAMMING-USING-JAVA-Multithreading.pptx
8.-OBJECT-ORIENTED-PROGRAMMING-USING-JAVA-Multithreading.pptx8.-OBJECT-ORIENTED-PROGRAMMING-USING-JAVA-Multithreading.pptx
8.-OBJECT-ORIENTED-PROGRAMMING-USING-JAVA-Multithreading.pptxsandhyakiran10
 
U4 JAVA.pptx
U4 JAVA.pptxU4 JAVA.pptx
U4 JAVA.pptxmadan r
 
Concurrency in Java
Concurrency in  JavaConcurrency in  Java
Concurrency in JavaAllan Huang
 
Multi threading
Multi threadingMulti threading
Multi threadinggndu
 
1.17 Thread in java.pptx
1.17 Thread in java.pptx1.17 Thread in java.pptx
1.17 Thread in java.pptxTREXSHyNE
 
Multithreading
MultithreadingMultithreading
Multithreadingbackdoor
 
Java Threads: Lightweight Processes
Java Threads: Lightweight ProcessesJava Threads: Lightweight Processes
Java Threads: Lightweight ProcessesIsuru Perera
 
Multithreading Presentation
Multithreading PresentationMultithreading Presentation
Multithreading PresentationNeeraj Kaushik
 
Operating system 27 semaphores
Operating system 27 semaphoresOperating system 27 semaphores
Operating system 27 semaphoresVaibhav Khanna
 

Similaire à Concurrency with java (20)

Concurrency Programming in Java - 05 - Processes and Threads, Thread Objects,...
Concurrency Programming in Java - 05 - Processes and Threads, Thread Objects,...Concurrency Programming in Java - 05 - Processes and Threads, Thread Objects,...
Concurrency Programming in Java - 05 - Processes and Threads, Thread Objects,...
 
Java threading
Java threadingJava threading
Java threading
 
multithreading
multithreadingmultithreading
multithreading
 
Java multithreading
Java multithreadingJava multithreading
Java multithreading
 
Java
JavaJava
Java
 
Java
JavaJava
Java
 
Multithreading
MultithreadingMultithreading
Multithreading
 
8.-OBJECT-ORIENTED-PROGRAMMING-USING-JAVA-Multithreading.pptx
8.-OBJECT-ORIENTED-PROGRAMMING-USING-JAVA-Multithreading.pptx8.-OBJECT-ORIENTED-PROGRAMMING-USING-JAVA-Multithreading.pptx
8.-OBJECT-ORIENTED-PROGRAMMING-USING-JAVA-Multithreading.pptx
 
U4 JAVA.pptx
U4 JAVA.pptxU4 JAVA.pptx
U4 JAVA.pptx
 
Concurrency in Java
Concurrency in  JavaConcurrency in  Java
Concurrency in Java
 
Multi threading
Multi threadingMulti threading
Multi threading
 
Multithreading in java
Multithreading in javaMultithreading in java
Multithreading in java
 
Scheduling Thread
Scheduling  ThreadScheduling  Thread
Scheduling Thread
 
1.17 Thread in java.pptx
1.17 Thread in java.pptx1.17 Thread in java.pptx
1.17 Thread in java.pptx
 
Md09 multithreading
Md09 multithreadingMd09 multithreading
Md09 multithreading
 
Multithreading
MultithreadingMultithreading
Multithreading
 
Java Threads: Lightweight Processes
Java Threads: Lightweight ProcessesJava Threads: Lightweight Processes
Java Threads: Lightweight Processes
 
Slide 7 Thread-1.pptx
Slide 7 Thread-1.pptxSlide 7 Thread-1.pptx
Slide 7 Thread-1.pptx
 
Multithreading Presentation
Multithreading PresentationMultithreading Presentation
Multithreading Presentation
 
Operating system 27 semaphores
Operating system 27 semaphoresOperating system 27 semaphores
Operating system 27 semaphores
 

Plus de Hoang Nguyen

Rest api to integrate with your site
Rest api to integrate with your siteRest api to integrate with your site
Rest api to integrate with your siteHoang Nguyen
 
How to build a rest api
How to build a rest apiHow to build a rest api
How to build a rest apiHoang Nguyen
 
Optimizing shared caches in chip multiprocessors
Optimizing shared caches in chip multiprocessorsOptimizing shared caches in chip multiprocessors
Optimizing shared caches in chip multiprocessorsHoang Nguyen
 
How analysis services caching works
How analysis services caching worksHow analysis services caching works
How analysis services caching worksHoang Nguyen
 
Hardware managed cache
Hardware managed cacheHardware managed cache
Hardware managed cacheHoang Nguyen
 
Directory based cache coherence
Directory based cache coherenceDirectory based cache coherence
Directory based cache coherenceHoang Nguyen
 
Python your new best friend
Python your new best friendPython your new best friend
Python your new best friendHoang Nguyen
 
Python language data types
Python language data typesPython language data types
Python language data typesHoang Nguyen
 
Programming for engineers in python
Programming for engineers in pythonProgramming for engineers in python
Programming for engineers in pythonHoang Nguyen
 
Extending burp with python
Extending burp with pythonExtending burp with python
Extending burp with pythonHoang Nguyen
 
Cobol, lisp, and python
Cobol, lisp, and pythonCobol, lisp, and python
Cobol, lisp, and pythonHoang Nguyen
 
Object oriented programming using c++
Object oriented programming using c++Object oriented programming using c++
Object oriented programming using c++Hoang Nguyen
 
Object oriented analysis
Object oriented analysisObject oriented analysis
Object oriented analysisHoang Nguyen
 
Data structures and algorithms
Data structures and algorithmsData structures and algorithms
Data structures and algorithmsHoang Nguyen
 

Plus de Hoang Nguyen (20)

Rest api to integrate with your site
Rest api to integrate with your siteRest api to integrate with your site
Rest api to integrate with your site
 
How to build a rest api
How to build a rest apiHow to build a rest api
How to build a rest api
 
Api crash
Api crashApi crash
Api crash
 
Smm and caching
Smm and cachingSmm and caching
Smm and caching
 
Optimizing shared caches in chip multiprocessors
Optimizing shared caches in chip multiprocessorsOptimizing shared caches in chip multiprocessors
Optimizing shared caches in chip multiprocessors
 
How analysis services caching works
How analysis services caching worksHow analysis services caching works
How analysis services caching works
 
Hardware managed cache
Hardware managed cacheHardware managed cache
Hardware managed cache
 
Directory based cache coherence
Directory based cache coherenceDirectory based cache coherence
Directory based cache coherence
 
Cache recap
Cache recapCache recap
Cache recap
 
Python your new best friend
Python your new best friendPython your new best friend
Python your new best friend
 
Python language data types
Python language data typesPython language data types
Python language data types
 
Python basics
Python basicsPython basics
Python basics
 
Programming for engineers in python
Programming for engineers in pythonProgramming for engineers in python
Programming for engineers in python
 
Learning python
Learning pythonLearning python
Learning python
 
Extending burp with python
Extending burp with pythonExtending burp with python
Extending burp with python
 
Cobol, lisp, and python
Cobol, lisp, and pythonCobol, lisp, and python
Cobol, lisp, and python
 
Object oriented programming using c++
Object oriented programming using c++Object oriented programming using c++
Object oriented programming using c++
 
Object oriented analysis
Object oriented analysisObject oriented analysis
Object oriented analysis
 
Object model
Object modelObject model
Object model
 
Data structures and algorithms
Data structures and algorithmsData structures and algorithms
Data structures and algorithms
 

Dernier

Nanopower In Semiconductor Industry.pdf
Nanopower  In Semiconductor Industry.pdfNanopower  In Semiconductor Industry.pdf
Nanopower In Semiconductor Industry.pdfPedro Manuel
 
AI Fame Rush Review – Virtual Influencer Creation In Just Minutes
AI Fame Rush Review – Virtual Influencer Creation In Just MinutesAI Fame Rush Review – Virtual Influencer Creation In Just Minutes
AI Fame Rush Review – Virtual Influencer Creation In Just MinutesMd Hossain Ali
 
Using IESVE for Loads, Sizing and Heat Pump Modeling to Achieve Decarbonization
Using IESVE for Loads, Sizing and Heat Pump Modeling to Achieve DecarbonizationUsing IESVE for Loads, Sizing and Heat Pump Modeling to Achieve Decarbonization
Using IESVE for Loads, Sizing and Heat Pump Modeling to Achieve DecarbonizationIES VE
 
IaC & GitOps in a Nutshell - a FridayInANuthshell Episode.pdf
IaC & GitOps in a Nutshell - a FridayInANuthshell Episode.pdfIaC & GitOps in a Nutshell - a FridayInANuthshell Episode.pdf
IaC & GitOps in a Nutshell - a FridayInANuthshell Episode.pdfDaniel Santiago Silva Capera
 
AI You Can Trust - Ensuring Success with Data Integrity Webinar
AI You Can Trust - Ensuring Success with Data Integrity WebinarAI You Can Trust - Ensuring Success with Data Integrity Webinar
AI You Can Trust - Ensuring Success with Data Integrity WebinarPrecisely
 
Meet the new FSP 3000 M-Flex800™
Meet the new FSP 3000 M-Flex800™Meet the new FSP 3000 M-Flex800™
Meet the new FSP 3000 M-Flex800™Adtran
 
activity_diagram_combine_v4_20190827.pdfactivity_diagram_combine_v4_20190827.pdf
activity_diagram_combine_v4_20190827.pdfactivity_diagram_combine_v4_20190827.pdfactivity_diagram_combine_v4_20190827.pdfactivity_diagram_combine_v4_20190827.pdf
activity_diagram_combine_v4_20190827.pdfactivity_diagram_combine_v4_20190827.pdfJamie (Taka) Wang
 
Artificial Intelligence & SEO Trends for 2024
Artificial Intelligence & SEO Trends for 2024Artificial Intelligence & SEO Trends for 2024
Artificial Intelligence & SEO Trends for 2024D Cloud Solutions
 
Machine Learning Model Validation (Aijun Zhang 2024).pdf
Machine Learning Model Validation (Aijun Zhang 2024).pdfMachine Learning Model Validation (Aijun Zhang 2024).pdf
Machine Learning Model Validation (Aijun Zhang 2024).pdfAijun Zhang
 
Connector Corner: Extending LLM automation use cases with UiPath GenAI connec...
Connector Corner: Extending LLM automation use cases with UiPath GenAI connec...Connector Corner: Extending LLM automation use cases with UiPath GenAI connec...
Connector Corner: Extending LLM automation use cases with UiPath GenAI connec...DianaGray10
 
Comparing Sidecar-less Service Mesh from Cilium and Istio
Comparing Sidecar-less Service Mesh from Cilium and IstioComparing Sidecar-less Service Mesh from Cilium and Istio
Comparing Sidecar-less Service Mesh from Cilium and IstioChristian Posta
 
Salesforce Miami User Group Event - 1st Quarter 2024
Salesforce Miami User Group Event - 1st Quarter 2024Salesforce Miami User Group Event - 1st Quarter 2024
Salesforce Miami User Group Event - 1st Quarter 2024SkyPlanner
 
NIST Cybersecurity Framework (CSF) 2.0 Workshop
NIST Cybersecurity Framework (CSF) 2.0 WorkshopNIST Cybersecurity Framework (CSF) 2.0 Workshop
NIST Cybersecurity Framework (CSF) 2.0 WorkshopBachir Benyammi
 
Igniting Next Level Productivity with AI-Infused Data Integration Workflows
Igniting Next Level Productivity with AI-Infused Data Integration WorkflowsIgniting Next Level Productivity with AI-Infused Data Integration Workflows
Igniting Next Level Productivity with AI-Infused Data Integration WorkflowsSafe Software
 
Anypoint Code Builder , Google Pub sub connector and MuleSoft RPA
Anypoint Code Builder , Google Pub sub connector and MuleSoft RPAAnypoint Code Builder , Google Pub sub connector and MuleSoft RPA
Anypoint Code Builder , Google Pub sub connector and MuleSoft RPAshyamraj55
 
Computer 10: Lesson 10 - Online Crimes and Hazards
Computer 10: Lesson 10 - Online Crimes and HazardsComputer 10: Lesson 10 - Online Crimes and Hazards
Computer 10: Lesson 10 - Online Crimes and HazardsSeth Reyes
 
Building AI-Driven Apps Using Semantic Kernel.pptx
Building AI-Driven Apps Using Semantic Kernel.pptxBuilding AI-Driven Apps Using Semantic Kernel.pptx
Building AI-Driven Apps Using Semantic Kernel.pptxUdaiappa Ramachandran
 
KubeConEU24-Monitoring Kubernetes and Cloud Spend with OpenCost
KubeConEU24-Monitoring Kubernetes and Cloud Spend with OpenCostKubeConEU24-Monitoring Kubernetes and Cloud Spend with OpenCost
KubeConEU24-Monitoring Kubernetes and Cloud Spend with OpenCostMatt Ray
 

Dernier (20)

Nanopower In Semiconductor Industry.pdf
Nanopower  In Semiconductor Industry.pdfNanopower  In Semiconductor Industry.pdf
Nanopower In Semiconductor Industry.pdf
 
201610817 - edge part1
201610817 - edge part1201610817 - edge part1
201610817 - edge part1
 
20150722 - AGV
20150722 - AGV20150722 - AGV
20150722 - AGV
 
AI Fame Rush Review – Virtual Influencer Creation In Just Minutes
AI Fame Rush Review – Virtual Influencer Creation In Just MinutesAI Fame Rush Review – Virtual Influencer Creation In Just Minutes
AI Fame Rush Review – Virtual Influencer Creation In Just Minutes
 
Using IESVE for Loads, Sizing and Heat Pump Modeling to Achieve Decarbonization
Using IESVE for Loads, Sizing and Heat Pump Modeling to Achieve DecarbonizationUsing IESVE for Loads, Sizing and Heat Pump Modeling to Achieve Decarbonization
Using IESVE for Loads, Sizing and Heat Pump Modeling to Achieve Decarbonization
 
IaC & GitOps in a Nutshell - a FridayInANuthshell Episode.pdf
IaC & GitOps in a Nutshell - a FridayInANuthshell Episode.pdfIaC & GitOps in a Nutshell - a FridayInANuthshell Episode.pdf
IaC & GitOps in a Nutshell - a FridayInANuthshell Episode.pdf
 
AI You Can Trust - Ensuring Success with Data Integrity Webinar
AI You Can Trust - Ensuring Success with Data Integrity WebinarAI You Can Trust - Ensuring Success with Data Integrity Webinar
AI You Can Trust - Ensuring Success with Data Integrity Webinar
 
Meet the new FSP 3000 M-Flex800™
Meet the new FSP 3000 M-Flex800™Meet the new FSP 3000 M-Flex800™
Meet the new FSP 3000 M-Flex800™
 
activity_diagram_combine_v4_20190827.pdfactivity_diagram_combine_v4_20190827.pdf
activity_diagram_combine_v4_20190827.pdfactivity_diagram_combine_v4_20190827.pdfactivity_diagram_combine_v4_20190827.pdfactivity_diagram_combine_v4_20190827.pdf
activity_diagram_combine_v4_20190827.pdfactivity_diagram_combine_v4_20190827.pdf
 
Artificial Intelligence & SEO Trends for 2024
Artificial Intelligence & SEO Trends for 2024Artificial Intelligence & SEO Trends for 2024
Artificial Intelligence & SEO Trends for 2024
 
Machine Learning Model Validation (Aijun Zhang 2024).pdf
Machine Learning Model Validation (Aijun Zhang 2024).pdfMachine Learning Model Validation (Aijun Zhang 2024).pdf
Machine Learning Model Validation (Aijun Zhang 2024).pdf
 
Connector Corner: Extending LLM automation use cases with UiPath GenAI connec...
Connector Corner: Extending LLM automation use cases with UiPath GenAI connec...Connector Corner: Extending LLM automation use cases with UiPath GenAI connec...
Connector Corner: Extending LLM automation use cases with UiPath GenAI connec...
 
Comparing Sidecar-less Service Mesh from Cilium and Istio
Comparing Sidecar-less Service Mesh from Cilium and IstioComparing Sidecar-less Service Mesh from Cilium and Istio
Comparing Sidecar-less Service Mesh from Cilium and Istio
 
Salesforce Miami User Group Event - 1st Quarter 2024
Salesforce Miami User Group Event - 1st Quarter 2024Salesforce Miami User Group Event - 1st Quarter 2024
Salesforce Miami User Group Event - 1st Quarter 2024
 
NIST Cybersecurity Framework (CSF) 2.0 Workshop
NIST Cybersecurity Framework (CSF) 2.0 WorkshopNIST Cybersecurity Framework (CSF) 2.0 Workshop
NIST Cybersecurity Framework (CSF) 2.0 Workshop
 
Igniting Next Level Productivity with AI-Infused Data Integration Workflows
Igniting Next Level Productivity with AI-Infused Data Integration WorkflowsIgniting Next Level Productivity with AI-Infused Data Integration Workflows
Igniting Next Level Productivity with AI-Infused Data Integration Workflows
 
Anypoint Code Builder , Google Pub sub connector and MuleSoft RPA
Anypoint Code Builder , Google Pub sub connector and MuleSoft RPAAnypoint Code Builder , Google Pub sub connector and MuleSoft RPA
Anypoint Code Builder , Google Pub sub connector and MuleSoft RPA
 
Computer 10: Lesson 10 - Online Crimes and Hazards
Computer 10: Lesson 10 - Online Crimes and HazardsComputer 10: Lesson 10 - Online Crimes and Hazards
Computer 10: Lesson 10 - Online Crimes and Hazards
 
Building AI-Driven Apps Using Semantic Kernel.pptx
Building AI-Driven Apps Using Semantic Kernel.pptxBuilding AI-Driven Apps Using Semantic Kernel.pptx
Building AI-Driven Apps Using Semantic Kernel.pptx
 
KubeConEU24-Monitoring Kubernetes and Cloud Spend with OpenCost
KubeConEU24-Monitoring Kubernetes and Cloud Spend with OpenCostKubeConEU24-Monitoring Kubernetes and Cloud Spend with OpenCost
KubeConEU24-Monitoring Kubernetes and Cloud Spend with OpenCost
 

Concurrency with java

  • 1. Programming Paradigms • Single Process • Multi Process • Multi Core/Multi Thread
  • 3. Process • Process A process runs independently and isolated of other processes. It cannot directly access shared data in other processes. The resources of the process are allocated to it via the operating system, e.g. memory and CPU time.
  • 4. Java Process Objects • ADTs, aggregate components, JavaBeans, monitors, business objects, remote RMI objects, subsystems, ... • May be grouped according to structure, role, ... • Usable across multiple activities — focus on SAFETY Activities • Messages, call chains, threads, sessions, scenarios, scripts, workflows, use cases, transactions, data flows, mobile computations
  • 5. Thread • Threads are so called lightweight processes which have their own call stack but an access shared data. Every thread has its own memory cache. If a thread reads shared data it stores this data in its own memory cache. A thread can re-read the shared data
  • 6. What is The Gain • Amdahl's Law • It states that a small portion of the program which cannot be parallelized will limit the overall speed-up available from parallelization. • A program solving a large mathematical or engineering problem will typically consist of several parallelizable parts and several non-parallelizable (sequential) parts. If p is the fraction of running time a sequential program spends on non-parallelizable parts, then • S = 1/p
  • 7. How much is the speed up • If the sequential portion of a program accounts for 10% of the runtime, we can get no more than a 10× speed-up, regardless of how many processors are added. This puts an upper limit on the usefulness of adding more parallel execution units. "When a task cannot be partitioned because of sequential constraints, the application of more effort has no effect on the schedule. The bearing of a child takes nine months, no matter how many women are assigned
  • 8. How does Java help to Parallel Programming • Has Threads since its inception • Threads have their own stack. But uses heap of the JVM • Has many constructs to control the concurrency • Programmer knowledge is very critical
  • 10. Thread Class Constructors • Thread(Runnable r) constructs so run() calls r.run() • — Other versions allow names, ThreadGroup placement Principal methods • start() activates run() then returns to caller • isAlive() returns true if started but not stopped • join() waits for termination (optional timeout) • interrupt() breaks out of wait, sleep, or join • isInterrupted() returns interruption state • getPriority() returns current scheduling priority • setPriority(int priorityFromONEtoTEN) sets it
  • 11. How to Implement a Thread • Subclass Thread. The Thread class itself implements Runnable, though its run method does nothing. An application can subclass Thread, providing its own implementation of run
  • 12. Thread Subclass public class HelloThread extends Thread { public void run() { System.out.println("Hello from a thread!"); } public static void main(String args[]) { (new HelloThread()).start(); } }
  • 13. Implement Runnable Interface public class HelloRunnable implements Runnable { public void run() { System.out.println("Hello from a thread!"); } public static void main(String args[]) { (new HelloRunnable()).start(); } }
  • 14. Pausing while executing • Thread.sleep causes the current thread to suspend execution for a specified period. • This is an efficient means of making processor time available to the other threads of an application or other applications that might be running on a computer system. The sleep method can also be used for pacing
  • 15. Thread Management • To directly control thread creation and management, simply instantiate Thread each time the application needs to initiate an asynchronous task. • To abstract thread management from the rest of your application, pass the application's tasks to an executor.
  • 16. Sleep Example • main declares that it throws InterruptedException. This is an exception that sleep throws when another thread interrupts the current thread while sleep is active. Since this application has not defined another thread to cause the interrupt, it doesn't bother to catch InterruptedException.
  • 17. Communicating with Thread • Interrupts • An interrupt is an indication to a thread that it should stop what it is doing and do something else. It's up to the programmer to decide exactly how a thread responds to an interrupt, but it is very common for the thread to terminate. This is the usage emphasized in this lesson.
  • 18. Interrupt requirement • A thread sends an interrupt by invoking interrupt on the Thread object for the thread to be interrupted. For the interrupt mechanism to work correctly, the interrupted thread must support its own interruption.
  • 19. Interrupt Status • The interrupt mechanism is implemented using an internal flag known as the interrupt status. Invoking Thread.interrupt sets this flag. When a thread checks for an interrupt by invoking the static method Thread.interrupted, interrupt status is cleared. The non-static isInterrupted method, which is used by one thread to query the interrupt status of another, does not change the interrupt status flag.
  • 20. Interrupted Exception and Status • By convention, any method that exits by throwing an InterruptedException clears interrupt status when it does so. However, it's always possible that interrupt status will immediately be set again, by another thread invoking interrupt.
  • 21. Thread Collaboration • The join method allows one thread to wait for the completion of another. If t is a Thread object whose thread is currently executing, • t.join(); • causes the current thread to pause execution until t's thread terminates. Overloads of join allow the programmer to specify a waiting period. However, as with sleep, join is dependent on the OS for timing, so you should not assume that join will wait exactly as long as you specify. • Like sleep, join responds to an interrupt by exiting with an InterruptedException.
  • 23. Synchronization • Threads communicate primarily by sharing access to fields and the objects reference fields refer to. This form of communication is extremely efficient, but makes two kinds of errors possible: thread interference and memory consistency errors. The tool needed to prevent these errors is synchronization.
  • 24. Synchronization Mechanisms • Thread Interference describes how errors are introduced when multiple threads access shared data. • Memory Consistency Errors describes errors that result from inconsistent views of shared memory. • Synchronized Methods describes a simple idiom that can effectively prevent thread interference and memory consistency errors. • Implicit Locks and Synchronization describes a more general synchronization idiom, and describes how synchronization is based on implicit locks. • Atomic Access talks about the general idea of operations that can't be interfered with by other threads.
  • 25. Synchronization Libraries Semaphores Maintain count of the number of threads allowed to pass Latches Boolean conditions that are set once, ever Barriers Counters that cause all threads to wait until all have finished Reentrant Locks Java-style locks allowing multiple acquisition by same thread, but that may be acquired and released as needed Mutexes Non-reentrant locks Read/Write Locks Pairs of conditions in which the readLock may be shared, but the writeLock is exclusive
  • 26. Semaphores Conceptually serve as permit holders • Construct with an initial number of permits (usually 0) • require waits for a permit to be available, then takes one • release adds a permit But in normal implementations, no actual permits change hands. • The semaphore just maintains the current count. • Enables very efficient implementation Applications • Isolating wait sets in buffers, resource controllers • Designs that would otherwise encounter missed signals — Where one thread signals before the other has even started waiting — Semaphores ‘remember’ how many times they were signalled
  • 27. Counter Using Semaphores class BoundedCounterUsingSemaphores { long count_ = MIN; Sync decPermits_= new Semaphore(0); Sync incPermits_= new Semaphore(MAX-MIN); synchronized long value() { return count_; } void inc() throws InterruptedException { incPermits_.acquire(); synchronized(this) { ++count_; } decPermits_.release(); } void dec() throws InterruptedException { decPermits_.acquire(); synchronized(this) { --count_; } incPermits_.release(); } }
  • 28. Using Latches • Conditions starting out false, but once set true, remain true forever • Initialization flags • End-of-stream conditions • Thread termination • Event occurrence
  • 29. Using Barrier Conditions Count-based latches • Initialize with a fixed count • Each release monotonically decrements count • All acquires pass when count reaches zero
  • 30. Liveness • A concurrent application's ability to execute in a timely manner is known as its liveness. This section describes the most common kind of liveness problem, deadlock, and goes on to briefly describe two other liveness problems, starvation and livelock.
  • 31. Deadlock • Deadlock describes a situation where two or more threads are blocked forever, waiting for each other. Here's an example. • Alphonse and Gaston are friends, and great believers in courtesy. A strict rule of courtesy is that when you bow to a friend, you must remain bowed until your friend has a chance to return the bow. Unfortunately, this rule does not account for the possibility that two friends might bow to each other at the same time.
  • 32. Starvation and Livelock • Starvation describes a situation where a thread is unable to gain regular access to shared resources and is unable to make progress. This happens when shared resources are made unavailable for long periods by "greedy" threads. • A thread often acts in response to the action of another thread. If the other thread's action is also a response to the action of another thread, then livelock may result.
  • 33. Guarded Blocks • Threads often have to coordinate their actions. The most common coordination idiom is the guarded block. Such a block begins by polling a condition that must be true before the block can proceed. There are a number of steps to follow in order to do this correctly.
  • 34. Guarded Block (cont..) • Constant polling for Condition • Use wait/notify method • Immutable Objects • Producer Consumer Example • A Synchronized Class Example
  • 35. Immutable Object 1. Don't provide "setter" methods — methods that modify fields or objects referred to by fields. 2. Make all fields final and private. 3. Don't allow subclasses to override methods. The simplest way to do this is to declare the class as final. A more sophisticated approach is to make the constructor private and construct instances in factory methods. 4. If the instance fields include references to mutable objects, don't allow those objects to be changed: – Don't provide methods that modify the mutable objects. – Don't share references to the mutable objects. Never store references to external, mutable objects passed to the constructor; if necessary, create copies, and store references to the copies. Similarly, create copies of your internal mutable objects when necessary to avoid returning the originals in your methods.
  • 36. High Level Concurrency Objects • Lock objects support locking idioms that simplify many concurrent applications. • Executors define a high-level API for launching and managing threads. Executor implementations provided by java.util.concurrent provide thread pool management suitable for large-scale applications. • Concurrent collections make it easier to manage large collections of data, and can greatly reduce the need for synchronization. • Atomic variables have features that minimize synchronization and help avoid memory consistency errors. • ThreadLocalRandom (in JDK 7) provides efficient generation of pseudorandom numbers from multiple threads.
  • 37. Lock Objects • Only one thread can own a implicit Lock object at a time. Lock objects also support a wait/notify mechanism, through their associated Condition objects. • The biggest advantage of Lock objects over implicit locks is their ability to back out of an attempt to acquire a lock. The tryLock method backs out if the lock is not available immediately or before a timeout expires (if specified). The lockInterruptibly method backs out if another thread sends an interrupt before the lock is acquired.
  • 39. Executors • In large-scale applications, it makes sense to separate thread management and creation from the rest of the application. Objects that encapsulate these functions are known as executors. • Executor Interfaces define the three executor object types. • Thread Pools are the most common kind of executor implementation. • Fork/Join is a framework (new in JDK 7) for taking advantage of multiple processors.
  • 40. Executor Interfaces • The java.util.concurrent package defines three executor interfaces: • Executor, a simple interface that supports launching new tasks. • ExecutorService, a subinterface of Executor, which adds features that help manage the lifecycle, both of the individual tasks and of the executor itself. • ScheduledExecutorService, a subinterface of ExecutorService, supports future and/or periodic execution of tasks.
  • 41. The Executor Interface • The Executor interface provides a single method, execute, designed to be a drop-in replacement for a common thread-creation idiom. If r is a Runnable object, and e is an Executor object you can replace • (new Thread(r)).start(); • with • e.execute(r);
  • 42. The ExecutorService Interface • The ExecutorService interface supplements execute with a similar, but more versatile submit method. Like execute, submit accepts Runnable objects, but also accepts Callable objects, which allow the task to return a value. The submit method returns a Future object, which is used to retrieve the Callable return value and to manage the status of both Callable and Runnable tasks. • ExecutorService also provides methods for submitting large collections of Callable objects. Finally, ExecutorService provides a number of methods for managing the shutdown of the executor. To support immediate shutdown, tasks should handle interrupts correctly.
  • 43. The ScheduledExecutorService Interface • The ScheduledExecutorService interface supplements the methods of its parent ExecutorService with schedule, which executes a Runnable or Callable task after a specified delay. In addition, the interface defines scheduleAtFixedRate and scheduleWithFixedDelay, which executes specified tasks repeatedly, at defined intervals.
  • 44. Thread Pools • Using worker threads minimizes the overhead due to thread creation. Thread objects use a significant amount of memory, and in a large- scale application, allocating and deallocating many thread objects creates a significant memory management overhead. • Tasks are submitted to the pool via an internal queue, which holds extra tasks whenever there are more active tasks than threads.
  • 45. Thread Pools • newFixedThreadPool • newCachedThreadPool • newSingleThreadExecutor • For customized needs one can construct • java.util.concurrent.ThreadPoolExecutor or java.util.concurrent.ScheduledThreadPoolExec utor
  • 46. Fork/Join • The fork/join framework is an implementation of the ExecutorService interface that helps you take advantage of multiple processors. It is designed for work that can be broken into smaller pieces recursively. The goal is to use all the available processing power to enhance the performance of your application.
  • 47. Basic Use • if (my portion of the work is small enough) – do the work directly • else – split my work into two pieces – invoke the two pieces and wait for the results • After your ForkJoinTask is ready, create one that represents all the work to be done and pass it to the invoke() method of a ForkJoinPool instance.
  • 48. Concurrent Collections • The java.util.concurrent package includes a number of additions to the Java Collections Framework • BlockingQueue • ConcurrentMap • ConcurrentSkipList • All of these collections help avoid Memory Consistency Errors by defining a happens-before relationship between an operation that adds an object to the collection with subsequent operations that access or remove that object.
  • 49. Atomic Variables • The java.util.concurrent.atomic package defines classes that support atomic operations on single variables. All classes have get and set methods that work like reads and writes on volatile variables.
  • 50. Concurrent Random Numbers • In JDK 7, java.util.concurrent includes a convenience class, ThreadLocalRandom, for applications that expect to use random numbers from multiple threads or ForkJoinTasks. • int r = ThreadLocalRandom.current() .nextInt(4, 77);
  • 51. Designing Objects for Concurrency Patterns for safely representing and managing state Immutability • Avoiding interference by avoiding change Locking • Guaranteeing exclusive access State dependence • What to do when you can’t do anything Containment • Hiding internal objects Splitting • Separating independent aspects of objects and locks