Implementarea Concurent, ei în limbaje de
programare
JAVA 3
Traian Florin S, erbănut, ă
FMI @ UNIBUC
1
Synchronization using class Lock
Readers-Writers Model
Executor, ExecutorService, Executors
Sequential consistency
2
Synchronization using class Lock
Lock vs synchronized
synchronized (ob) { ... }
• Uses the intrinsic lock of the object
• Forces a structured approach to synchronization:
• intrinsic lock automatically released upon exiting the block
Objects of classes implementing the Lock interface
• Manage their own locks
• more flexible
• threads can access locks in any order;
• making sure the lock is released falls on the programmer
Lock l = ...
l.lock();
try {
...
} finally { l.unlock(); }
3
Avoiding interference using Lock
public class NonInterference {
static int c = 0;
public static void main(String[] args)
throws InterruptedException {
Lock cLock = new ReentrantLock();
Thread myThread = new Thread(() -> {
for (int x = 0; x < 5000; ++x)
{cLock.lock(); try {c++;} finally {cLock.unlock();}}
});
myThread.start();
for (int x = 0; x < 5000; ++x)
{cLock.lock(); try {c--;} finally {cLock.unlock();}}
myThread.join();
System.out.println("c = " + c);
}
}
4
interface Lock
void lock() Acquires lock associated to object; may block
void unlock() Releases lock associated to object; not blocking
void lockInterruptibly() Acquires associated lock - if the
thread is not interrupted; may block
boolean tryLock() Acquires the lock if available when invoked;
not blocking
boolean tryLock(long time, TimeUnit unit) Acquires the
lock if it becomes available within the given time
Condition newCondition() Creates a new Condition variable
corresponding to the current Lock instance.
5
interface Condition
• Implements methods similar to wait and notify for Locks
await(), await(long time, TimeUnit unit) Current
threads waits for a signal on this condition
signal(), signalAll() one/all thread(s) waiting for this
condition is/are signaled to wake.
• Similarly to Object, conditions are linked to a Lock object
• lock must be acquired before calling wait()
• Multiple conditions can coexist for the same lock
6
Better Producer-Consumer Solution using Lock and Condition
(I)
public class Cell<T> implements DropBox<T> {
private T cell = null;
private boolean open = true;
private Lock cellLock;
private Condition putCond;
private Condition getCond;
public Cell() {
cellLock = new ReentrantLock();
putCond = cellLock.newCondition();
getCond = cellLock.newCondition();
}
7
Better Producer-Consumer Solution using Lock and Condition
(put)
@Override public boolean put(T message)
throws InterruptedException {
cellLock.lock();
try {
while (open && cell != null) putCond.await();
if (!open) return false;
cell = message;
getCond.signal();
return true;
} finally {
cellLock.unlock();
}
}
8
Better Producer-Consumer Solution using Lock and Condition
(take)
@Override public Optional<T> take()
throws InterruptedException {
cellLock.lock();
try {
while (open && cell == null) getCond.await();
if (open) putCond.signal();
T message = cell;
cell = null;
return Optional.ofNullable(message);
} finally {
cellLock.unlock();
}
}
9
Better Producer-Consumer Solution using Lock and Condition
(close)
@Override public void close() {
cellLock.lock();
try {
open = false;
putCond.signalAll();
getCond.signalAll();
} finally {
cellLock.unlock();
}
}
}
Notes
• using different conditions for put and take
• Advantage: no need to wake all threads each time something
changes
10
Readers-Writers Model
Readers-Writers Interaction Model
• Multiple threads need concurrent access to the same resource
• Some threads write (writers), others only read (readers).
• The resource can be read simultaneously by multiple readers
• The resource cannot be written simultaneously
• The resource cannot be simultaneously read and written
Expressed in Java through the ReadWriteLock interface
readLock() yields the lock for readers
writeLock() yields the lock for writers
11
Addressing non-interference using ReadWriteLock (reader
thread)
public class NonInterferenceRW {
static int c;
public static void main(String[] args)
throws InterruptedException {
final ReadWriteLock lock = new ReentrantReadWriteLock();
Runnable reader = () -> {
lock.readLock().lock();
try {
System.out.println(Thread.currentThread().getName()
+ " counter: " + c);
} finally { lock.readLock().unlock(); }
};
12
Addressing non-interference using ReadWriteLock (writer
threads)
Thread incThread = new Thread(() -> {
for (int x = 0; x < 5000; ++x) {
lock.writeLock().lock(); try {
for (int i = 0; i < 5; i++)
{ c++; Thread.yield(); }
} finally { lock.writeLock().unlock(); }
}});
Thread decThread = new Thread(() -> {
for (int x = 0; x < 5000; ++x) {
lock.writeLock().lock(); try {
for (int i = 0; i < 5; i++)
{ c--; Thread.yield(); }
} finally { lock.writeLock().unlock(); }
}});
13
Addressing non-interference using ReadWriteLock (main setup)
incThread.start();
decThread.start();
ExecutorService executorService =
Executors.newFixedThreadPool(2);
for (int i = 0; i < 100; i++)
executorService.execute(reader);
executorService.shutdown();
while (!executorService.isTerminated()) {
executorService.awaitTermination(1, TimeUnit.SECONDS);
}
incThread.join();
decThread.join();
System.out.println("c = " + c);
}
}
14
Executor, ExecutorService,
Executors
Executor and ExecutorService interfaces
Executor is an abstraction over Thread
void execute(Runnable task) Executes a task; whether
blocking or non-blocking, implementation decides
ExecutorService enhances the Executor functionalities
• . . . with ways to control execution
for (int i = 0; i < 100; i++) executorService.execute(reader);
executorService.shutdown();
while (!executorService.isTerminated()) {
executorService.awaitTermination(1, TimeUnit.SECONDS);
}
• . . . with ways to wait for results (next section)
15
class Executors
Provides static methods for creating ExecutorServices
static ExecutorService newCachedThreadPool() creates a
pool of threads to execute tasks. Reuses ended
threads. Uses a queue for tasks.
static ExecutorService newFixedThreadPool(int nThreads)
creates pool of nThreads threads to execute tasks.
Uses a (blocking) queue for scheduling tasks.
static ExecutorService newSingleThreadExecutor()
creates a single-threaded pool for executing tasks.
Uses a queue for tasks.
16
Asynchronous functions in Java: Callable, Future
Callable<T>
• Abstraction for actions (concurrent or not) returning a result
• think of it as a Runnable returning a value.
Callable<Integer> giveMeFive = () -> 5;
Future<T>
The promise of an Executor to deliver the result of a Callable
T get() Obtains the result promised by the Future. May block
waiting for the action to conclude
The submit method from ExecutorService
Future<T> submit(Callable<T> task) Schedules a task for
execution, returning a promise to deliver its result
17
Future
• ExecutorService.submit(task) returns a Future
• does not block; calling thread continues executing tasks
• even for a single-threaded Executor
• Result promised Future is obtained using get()
• get() blocks calling thread until result becomes available.
• if the thread executing the Callable is interrupted, throws
• isDone() called for a Future tells whether result is available.
18
Future example using isDone
public class FutureExample {
public static void main(String[] args) throws Exception {
ExecutorService executor =
Executors.newSingleThreadExecutor();
Future<Integer> future = executor.submit(() -> {
int time = ThreadLocalRandom.current().nextInt(1000, 5000);
Thread.sleep(time); return time;
});
while (!future.isDone())
{ System.out.println("Task not done ...");
Thread.sleep(500); }
System.out.println("Task duration: " + future.get());
executor.shutdown();
}
}
19
ExecutorService: invokeAll and invokeAny
List<Future<T>>
invokeAll(Collection<? extends Callable<T>> tasks)
Schedules all tasks for execution
• returns a Future for each task
• Blocks untill all tasks are done.
T invokeAny(Collection<? extends Callable<T>> tasks)
Schedules all taks for execution
• returns one of the results
• the other tasks are canceled
20
invokeAll example
Optional<To> mapReduce(Collection<From> c,
Function<From, To> map,
BinaryOperator<To> reduce)
throws Exception {
return
executor.invokeAll(
c.stream()
.map( e -> ((Callable<To>) () -> map.apply(e)) )
.collect(Collectors.toList())
).stream()
.map(InvokeAllExample::get)
.reduce(reduce);
}
21
invokeAny example
• Allows concurrent execution of multiple tasks
• Choses the task finishing first
• Useful when having more methods for solving the same problem
int search(Integer key)
throws ExecutionException, InterruptedException {
return executor.invokeAny(Arrays.asList(
() -> search1(key),
() -> search2(key),
() -> search3(key)));
}
22
Sequential consistency
Concurrent objects and serial specification
Concurrent objects
Shared entities upon which a thread can perform certain operations
Serial specification
The valid behavior of a concurrent object (in isolation)
• we only observe the operations performed on that object
23
Concurrent object example: shared memory location
Operations
read Reading the value from the memory location
write Writing a value into the memory location
Serial specification
Every read operation yields the value written by the latest write.
24
Concurent object example: mutex (lock)
Operations
lock acquires the lock
unlock releases the lock
Serial specification
• #lock - #unlock is either 0 or 1 for all prefixes
• sequence of lock unlock pairs
• last unlock can miss
• Consecutive lock - unlock operations belong to same thread
25
Formalizing sequential consistency [Attiya&Welch, 1994]
Legal execution
• Any concurrent object satisfies its serial specification
• When restricting the execution to that object alone.
Execution reordering
A permutation of the events in the original execution such that its
restriction to each thread is the same as in the original execution
Sequential consistent execution
An execution admitting a legal reordering
Guarantees offered by sequential consistency
• Execution happens as if it were legal
• Programmer can assume each concurrent object behaves
according to its serial specification
26
The Java memory model
• Sequential consistency <= program is correctly synchronized
Correctly synchronized no data-races
Data-race conflictual access not ordered by happens-before
concurrent access to same location, one is write
The Happens-before relation hb(x,y)
Thread order x before y within the same thread => hb(x,y)
Synchronization x synchronizes with subsequent action y =>
hb(x,y)
Transitivity hb(x,y) and hb(y,z) => hb(x,z)
Constructor-Finalizer If x is the end of a constructor and y is the
call to finalize for that object => hb(x,y)
27
Synchronization order
• unlock synchronizes with subsequent locks on same monitor
• write of volatile v synchronizes with subsequent reads of v
• Thread start synchronizes with first operation in that thread
• Final operation in thread synchronizes with any operation
detecting that the thread has ended
28
