Concurrent Programming in Java

t.isAlive(); //checks if thread is alive
t.interrupt(); // stops thread
Communication betwen Threads
Threads communicate by sharing access to fields
● ●
This kind of communication can lead to:
Why Concurrency?
Concurrency vs Paralellism
Concurrent
context switching
Paralell
Amdahl's Law
The speedup of a program using multiple processors in parallel computing is limite
ExecutorService + Callable + Future
//submits a task to be executed asynchronously Future<String> future = executorService.submit(new Callable<String>() { @Override public String call() throws Exception { return "hi"; } }); //blocks until the result is ready String message = future.get();
ExecutorService
//creates the executor service ExecutorService executorService = Executors.newFixedThreadPool(5);
//submits a task to be executed asynchronously Future<String> future = executorService.submit(new Callable<String>() { @Override public String call() throws Exception { return "hi"; } });
Threads => less overhead Size of Pool => less risk of OOM
– Control – Easily
retrieve values of asynchronous computation (Future)
– KeepAliveTime
– ThreadFactory – RejectedExecutionHandler
●
Predefined Executors
/2014/01/choosing-executorservice.html
Executor
Thread A
//thread A increments counter counter++;
Thread B
//thread B prints out counter, // right after A's change System.out.println(counter);
Which value prints out B?
Threads
To prevent Thread Interference and Memory Consistency errors, we use synchronization, that can introduce Thread Contention
●
– Deadlocks:
threads wait for each other
●
– Everytime
a thread blocks or sleeps, context is switched with concurrent access to shared
●
Memory is shared around threads
– Problem
objects
●
Difficult to control flow
Blocks until result is ready (thread has finished)
Callable allows threads to return a result ●Future holds the result of the asynchronous computation
●
● ●
Parent Interface of ExecutorService Just provides one method: execute
Executor executor = new ThreadPoolExecutor(...) executor.execute(new Runnable() { public void run() { //execute task } });
Concurrent Programming in Java
Index
● ● ● ● ● ● ● ●
Concurrency Threads Executors ForkJoin Paralell Streams CompletableFuture RXJava Actors
Concurrency?
„a property of systems in which several computations are executing simultaneously, and potentially interacting with each other“
/wiki/Concurrency_(computer_science)
there's no guarantee that thread A's change to counter will be visible to thread B, unless the programmer has established a happens-before relationship between these two statements
//blocks until the result is ready String message = future.get(); // no more executions will be accepted executorService.shutdown();
// blocks until all tasks have completed execution executorService.awaitTermination(1, TimeUnit.SECONDS);
● ● ●
ExecutorService Futures
ExecutorService
Takes care of executing (and controlling the execution) of asynchronous tasks
● ●
Configurable Thread Pools
– CorePoolSize – MaximumPoolSize,
– Memory
Thread Interference
–sequence
of steps overlap, leading to wrong results
Memory Consistency Errors
// counter is shared by 2 threads int counter = 0;
For example, if 95% of the program can be parallelized, the theoretical maximum speedup using parallel comp
Concurrency
context switch
Paralellism
no context switch
– Thread
interference: sequence of steps overlap, leading to wrong results. consistency errors: changes to objects are not immediatelly visible to other threads
– Otherwise,
if mayInterruptIfRunning is true, it will Interrupt
●
isDone()
ExecutorService – more methods
List<Future> invokeAll(Collection <Callable> Tasks
invoke* and await* methods support timeout parameters. If task doesn't finish on time, method still returns
●
ExecutorService - Pros
●
Now we can:
– Cache
– Livelocks:
Deadlock
Thread Problems
●
Expensive to create
– CPU
+ RAM (around. 512Kb per Thread!)
Performance overhead when CPU does context switching (switching between threads)