Progetto di reti di Calcolatori e Sistemi Informativi

1 

Progetto di reti di Calcolatori e Sistemi 

Informatici 

PdR_09010 - Stefano Millozzi 

Stefano Millozzi

2 

java.util.concurrent 


Introduzione al package

Le Motivazioni dietro java.util.concurrent 

Nuovo package ideato da un gruppo di esperti sotto la 

guida di Doug Lea (JSR166)‏ 

Nasce dall’osservazione, che java, nonostante prevedesse 

dei meccanismi per la programmazione concorrente sin 

dalla nascita, da allora non ha fatto significativi passi in 

avanti in questo campo 

I meccanismi che mette a disposizione sono piuttosto 

primitivi e rigidi; necessità di astrazione 

Obbiettivi, dichiaratamente immodesti, creare una 

libreria che rappresenti per la programmazione 

concorrente, quello che il Java Collections Framework ha 

rappresentato per le collezioni 

3 

PdR_09010 - Stefano Millozzi

J2SE 5.0 e la Programmazione Concorrente 

Package di principale interesse 


framework per la scrittura di codice concorrente 

java.util.concurrent.locks 

framework con gli usuali strumenti a supporto dei problemi di 

competizione e cooperazione 

java.util.concurrent.atomic 

classi wrapper che offrono operazioni atomiche grazie ad istruzioni 

del tipo TestAndSet, qui chiamate CompareAndSet (CAS), aggiunte al 

supporto della JVM 

alcune novità hanno causato cambiamenti anche in altri 

package 

ad es. java.util.Queue 

4 


5 

Lightweight Executable Framework 

Thread all’ennesima potenza 


Lightweight Executable Framework 

Con i meccanismi nativi di java dobbiamo contestualmente 

creare i thread 

new Thread()‏ 

invocazione del metodo Thread.start()‏ 

sottomettere i task da eseguire 

sarà quello associabile al metodo run() 

Vogliamo disaccoppiare i due aspetti, per poter variare uno senza dover cambiare 

anche l’altro 

Idea di base: lo stesso thread può far avanzare molteplici attività non correlate 

(worker thread)‏ 

Il disaccoppiamento tra la sottomissione di Runnable (in generale task) ed il modo 

in cui saranno effettivamente eseguiti consente di variare indipendentemente la 

politica di esecuzione 

Ad es. si possono applicare politiche tese a: 

contenere il numero di thread creati 

pooling dei thread, caching e riuso dei thread 

attuare una politica di priorità personalizzata 

programmare temporalmente l’esecuzione 

6 


Le classi in gioco/1: Executor 

Executor 

An object that executes submitted Runnable tasks. 

ExecutorService (extends Executor) 

An Executor that provides methods to manage termination and 

methods that can produce a Future for tracking progress of one or 

more asynchronous tasks. 

ScheduledExecutorService (extends ExecutorService) 

An ExecutorService that can schedule commands to run after a given 

delay, or to execute periodically. 

Executors 

7 

Factory and utility methods for Executor, ExecutorService, 

ScheduledExecutorService, ThreadFactory, and Callable classes 

defined in this package. 


Le classi in gioco/2: Task & sync 

Runnable 

The Runnable interface should be implemented by any class whose 

instances are intended to be executed by a thread. The class must 

define a method of no arguments called run. 

Callable 

A task that returns a result and may throw an exception. 

Implementors define a single method with no arguments called call. 

Future 

8 

A Future represents the result of an asynchronous computation. 

Methods are provided to check if the computation is complete, to 

wait for its completion, and to retrieve the result of the computation. 

The result can only be retrieved using method get when the 

computation has completed, blocking if necessary until it is ready. 

Cancellation is performed by the cancel method. 


Executor 

Executor 

9 

Motore in grado di mandare in esecuzione un oggetto Runnable 

L’interfaccia alla base di questo framework è 

Method java.util.concurrent.Executor 

Summary 

void 

execute(Runnable command) 

Executes the given command at some time in 

the future. 

Sono fornite possibili implementazioni dai metodi factory della 

classe di utilità java.util.concurrent.Executors 

ExecutorService 

ScheduledExecutorService 


Executors 

Method Summary 

java.util.concurrent.Executors 

Factory per ottenere oggetti after a given Executor delay, or to per execute poter periodically. sottomettere nuovi 

task 

10 

static 


static 


static 


static 


static 


newCachedThreadPool() Creates a thread pool that creates new 

threads as needed, but will reuse previously constructed threads 

when available. 

newFixedThreadPool(int nThreads) 

Creates a thread pool that reuses a fixed set of threads operating off 

a shared unbounded queue. 

newScheduledThreadPool(int corePoolSize) 

Creates a thread pool that can schedule cmds to run after a given 

delay, or to execute periodically. 

newSingleThreadExecutor() 

Creates an Executor that uses a single worker thread operating off an 

unbounded queue. 

newSingleThreadScheduledExecutor() 

Creates a single-threaded executor that can schedule cmds to run 


Esempio 

Realizzare un programma semplice programma Java che 

avvia 5 task in parallelo, usando il metodo 

newCachedThreadPool() di Executors 

11 

Ogni task stampa un messaggio di avvio, poi si mette in sleep 

per 5 secondi e uno di termine. 

Ripetere lo stesso test usando il metodo 

newFixedThreadPool(3) di Executors 


ExecutorService/1 


Future 

Future 

Future 

Metodi per la sottomissione dei lavori 

12 


Interface ExecutorService 

All Superinterfaces: 

Executor 

All Known Subinterfaces: 


submit(Callable task) Submits a value-returning task for 

execution and returns a Future representing the pending results of 

the task. 

submit(Runnable task) Submits a Runnable task for execution and 

returns a Future representing that task. 

submit(Runnable task, T result) Submits a Runnable task for 

execution and returns a Future representing that task that will upon 

completion return the given result 


ExecutorService /2 

metodi per la gestione della fine servizio di esecuzione 


13 

boolean 

boolean 

boolean 

void 

List 

awaitTermination(long timeout, TimeUnit unit) Blocks until all tasks have 

completed execution … 

isShutdown() Returns true if this executor has been shut down. 

isTerminated() Returns true if all tasks have completed… 

shutdown() Initiates an orderly shutdown in which previously submitted 

tasks are executed, but no new tasks will be accepted. 

shutdownNow() Attempts to stop all actively executing tasks, halts the 

processing of waiting tasks, and returns a list of the tasks that were 

awaiting execution. 


Note sull’uso del metodo Shutdown 

Quando si crea un oggetto ExecutorService, vengono avviati 

anche alcuni thread di servizio interni ad essa 

Questi thread vendono mantenuti attivi per tutto il tempo in cui è 

possibile sottomettere nuovi task 

vengono terminati solo quando si esegue shutdown e terminano i 

Task da elaborare 

Se non si esegue il comando shutdown/shutdowNow, la JVM 

resta attiva anche se il metodo main è terminato. 

Restano infatti attivi i thread interni degli oggetti ExecutorService 

Esempio 

@see TestExecutors1.java 

Commentare le istruzioni e.shutdown() nei metodi test1 e test2 e 

verificare se il processo JVM alla fine del programma termina oppure no 

14 


java.util.concurrent.Callable 


V 

Introdotti per gli ExecutorService 

Simile a java.lang.Runnable ma consente di restituire un valore 

15 

call() 

Computes a result, or throws an exception if unable to do so. 


java.util.concurrent.Future (1)‏ 

Con i lightweight executable framework, la sottomissione 

di un task viene disaccoppiata dall’effettiva esecuzione 

I task saranno eseguiti “at some time in the future” 

Pertanto, in seguito alla sottomissione gli Executor non 

restituiscono i risultati della computazione, ma Future, 

ovvero oggetti che incapsulano un risultato 

potenzialmente ancora da calcolare 

Se si cerca di leggere un risultato non ancora disponibile 

si deve aspettare 

16 


Future (2)‏ 


boolea 

n 

boolea 

n 

17 

V 

V 

boolea 

n 

cancel(boolean mayInterruptIfRunning) Attempts to cancel 

execution of this task. 

get() Waits if necessary for the computation to complete, and then 

retrieves its result. 

get(long timeout, TimeUnit unit) Waits if necessary for at most 

the given time for the computation to complete, and then retrieves 

its result, if available. 

isCancelled() Returns true if this task was cancelled before it 

completed normally. 

isDone() Returns true if this task completed. 


Un Esempio di Utilizzo di Callable 

Scrivere un algoritmo di ordinamento parallelo in cui il 

vettore iniziale viene diviso in varie porzioni, ordinate 

separatamente e poi fuse insieme (merge ordinato) 

18 

Confrontare i tempi di esecuzione tra l’approccio parallelo e 

uno sequenziale in cui il vettore non viene separato 

Confrontare anche la soluzione in cui l’ordinamento dei due 

subarray è eseguito sequenzialmente 

Utilizzare un algoritmo di ordinamento inefficiente O(n^2) per 

poter meglio apprezzare l’effetto della ripartizione del lavoro 

@see ParallelSorting.java 


java.util.concurrent.FutureTask 

Constructor Summary 

FutureTask(Callable callable) 

Creates a FutureTask that will upon running, execute the given Callable. 

FutureTask(Runnable runnable, V result) 

Creates a FutureTask that will upon running, execute the given Runnable, 

and arrange that get will return the given result on successful completion. 

19 




ScheduledFuture 




Permette di schedulare i task ad intervalli regolari 

Utilizzo come timer 

20 

schedule(Callable callable, long delay, TimeUnit unit) 

Creates and executes a ScheduledFuture that becomes enabled 

after the given delay. 

schedule(Runnable command, long delay, TimeUnit unit) 

Creates and executes a one-shot action that becomes enabled 

after the given delay. 

scheduleAtFixedRate(Runnable command, long initialDelay, 

long period, TimeUnit unit) 

Creates and executes a periodic action …. 

scheduleWithFixedDelay(Runnable command, 

long initialDelay, long delay, TimeUnit unit) 

Creates and executes a periodic action … 


Conseguenze nell’uso di Executable Framework (1)‏ 

Perdita di identità dei thread – ovvero della 

corrispondenza thread / task 

i thread possono essere riciclati e comunque si perde l’identità 

dell’oggetto java.lang.Thread 

Le dipendenze reciproche tra thread sono pericolose 

perché la politica di esecuzione potrebbe causare 

l’invalidamento dell’assunzione di progresso finito. 

Possibili soluzioni: 

prevedere un adeguato numero di worker thread 

usarli solo nel caso che è noto non possano esserci 

dipendenze, ad es. sessioni http 

creare politiche di gestione delle code che tengano conto delle 

dipendenze 

21 


Conseguenze dei Lightweight Executable Framework 

(2)‏ 

Saturazione del pool di worker thread a causa 

dell’eccessiva frequenza delle richieste. Soluzioni: 

22 

aumentare il numero di worker thread 

usare un buffer illimitato di accodamento delle richieste 

back-pressure: far diminuire la frequenza delle richieste 

con protocolli più articolati che prevedono interazioni con il client 

ritardando l’accettazione di nuove richieste 

passando in modalità di servizio single-threaded 

fare il lavoro nel thread di chi sottomette i task per rallentarlo 

abbandonare alcune richieste 

le richieste nuove (barbiere dormiente)‏ 

le richieste vecchie 



(3)‏ 

Gestione dei thread 

23 

lazy construction: i worker thread sono creati ed organizzati in 

un pool la cui dimensione può rispondere a queste esigenze 

contrastanti 

minimizzare il tempo di creazione dei thread 

riciclare vecchi thread per servire nuove richieste 

ottimizzare lo sfruttamento delle risorse allocate 

eliminare thread allo scadere di un time-out sull’inattività 



(4)‏ 

24 

Cancellazione dei thread. Bisogna distinguere tra cancellazione 

di un task 

di un worker thread 

di un ExecutorService 


Riepilogo delle principali classi 

25 

Executor 


Executors 

(factory) 


execute() 

schedule() 

submit() 

Future 

Scheduled 

Future 


Callable 

Runnable

26 

Lock e Semafori 

Primitive di sincronizzazione 


Lock e Condition 

Costrutto che può essere introdotto al posto dei metodi 

synchronized, wait e signal 

27 

Lock permette di regolare l’accesso (mutua esclusione) di una 

parte di codice, in maniera simile a quanto accade per 

synchonized(oggetto){} 

Con la classe Condition (ricavata direttamente dal Lock) è 

possibile fare wait e signal 


I Lock: java.util.concurrent.locks.Lock 


Lock implementations provide more extensive locking operations than can 

be obtained using synchronized methods and statements. 

28 

void 

void 

Condition 

boolean 

boolean 

void 

lock() Acquires the lock. 

lockInterruptibly() Acquires the lock unless the current thread is 

interrupted. 

newCondition() Returns a new Condition instance that is bound to 

this Lock instance. 

tryLock() Acquires the lock only if it is free at the time of invocation. 

tryLock(long time, TimeUnit unit) Acquires the lock if it is free 

within the given waiting time and the current thread has not been 

interrupted. 

unlock() Releases the lock. 


java.util.concurrent.locks.Condition 


void await() Causes the current thread to wait until it is signalled or interrupted. 

boolean 

Condition factors out the Object monitor methods (wait, notify and 

notifyAll) into distinct objects to give the effect of having multiple 

wait-sets per object, by combining them with the use of arbitrary 

Lock implementations. 

29 

long 

void 

boolean 

void 

void 

await(long time, TimeUnit unit) Causes the current thread to wait until it is signalled or 

interrupted, or the specified waiting time elapses. 

awaitNanos(long nanosTimeout) … 

awaitUninterruptibly() Causes the current thread to wait until it is signalled. 

awaitUntil(Date deadline) …. 

signal() Wakes up one waiting thread. 

signalAll() Wakes up all waiting threads. 


Implementazioni di Lock e Condition 

java.util.concurrent.locks.Lock e 

java.util.concurrent.locks.Condition sono interfacce 

java.util.concurrent.locks.ReentrantLock è una 

implementazione di lock rientranti 

30 

lo stesso thread può fare più lock() senza bloccarsi 

con il metodo factory Lock.newCondition() si ottiene una 

implementazione anonima delle variabili condizione 


Esempio di Utilizzo dei Lock 

Lock l = una implementazione di Lock; 

l.lock(); 

try { 

} 

31 

regione critica sulla risorsa condivisa 

eventuale wait, se la risorsa non è disponibile 

finally { 

} 

l.unlock(); 


Buffer Circolare (1)‏ 

Implementiamo un buffer circolare di dimensione finita 

adatto ad essere utilizzato da molteplici thread 

N.B. la classe ArrayBlockingQueue fornisce le medesime 

funzionalità 

Utilizziamo 

32 

Lock 

Variabili Condizione 



import java.util.concurrent.*; 

public class BoundedBuffer { 

33 

private Data buffer[]; 

private int first; 

private int last; 

private int numberInBuffer; 

private int size; 

private Lock lock = new ReentrantLock(); 

private final Condition notFull = lock.newCondition(); 

private final Condition notEmpty = Lock.newCondition(); 

//… 



//… 

public BoundedBuffer(int length) { 

} 

34 

size = length; 

buffer = (Data[]) new Object[size]; 

last = 0; 

first = 0; 

numberInBuffer = 0; 

//… 



public void put(Data item)‏throws InterruptedException { 

lock.lock(); 

try { 

while (numberInBuffer == size) 

notFull.await(); 

last = (last + 1) % size; 

numberInBuffer++; 

buffer[last] = item; 

notEmpty.signal(); 

} finally { 

lock.unlock(); 

} 

} 

//… 

35 



//… 

public Data get() throws InterruptedException { 

lock.lock(); 

try { 

while (numberInBuffer == 0) 

notEmpty.await(); 

first = (first + 1) % size ; 

numberInBuffer--; 

notFull.signal(); 

return buffer[first]; 

} finally { 

lock.unlock(); 

} 

} 

} 

36 


Read/Write Lock (1)‏ 

Si tratta di una coppia di lock associati tra loro 

37 

uno, detto lock di lettura (read lock), consente ai thread che lo 

possiedono di fare letture sulla risorsa protetta 

l’altro, detto lock di scrittura (write lock), consente ai thread 

che lo possiedono di fare scritture sulla risorsa protetta 

Utili per proteggere l’accesso a strutture condivise 

evitando fenomeni di interferenza e lunghe attese 

(passive) senza compromettere eccessivamente il grado di 

parallelismo in presenza di 

una maggioranza per numero e durata di operazioni di lettura 

una minoranza per numero e durata di operazioni di scrittura 



Molteplici thread possono ottenere il read lock 

concorrentemente 

Solo un thread alla volta può ottenere il write lock 

Se un thread chiede il lock di lettura, può procedere 

anche se altri thread già lo possiedono ma solo se 

nessuno già possiede il lock in scrittura 

Se un thread chiede il lock in scrittura, può procedere 

solo quando ottiene l’accesso in mutua esclusione alla 

risorsa 

38 

tutti gli altri thread non possono disporre né del lock di 

scrittura né di quello in lettura 



In un certo senso, i read/write lock rispecchiano il 

concetto che le aree di memoria hanno molteplicità 

39 

infinita in lettura 

seriale in scrittura 

Rispetto alla semplice mutua esclusione, il livello di 

parallelismo raggiungibile dipende fortemente dalla 

frequenza e dal tipo di accessi lettura/scrittura 



Alcune delle scelte progettuali necessarie: 

40 

se sia scrittori che lettori sono in attesa passiva, chi preferire 

non appena la risorsa si libera da uno scrittore? e da un 

lettore? 

il lock di scrittura è rientrante? e quello di lettura? 

un lock di lettura può essere promosso a lock di scrittura? 

secondo quali politiche? 

un lock di scrittura può essere retrocesso a lock di lettura? 

secondo quali politiche? 

… 


java.util.concurrent.locks.ReadWriteLock 


Lock 

Lock 

41 

readLock() Returns the lock used for reading. 

writeLock() Returns the lock used for writing. 


ReentrantReadWriteLock (1)‏ 


ReentrantReadWriteLock() 

Creates a new ReentrantReadWriteLock with default ordering properties. 

ReentrantReadWriteLock(boolean fair) 

Creates a new ReentrantReadWriteLock with the given fairness policy. 

Una possibile implementazione 

una politica fair (opzionale) di gestione delle richieste 

lock rientranti 

locking interrompibile sia sul lock di lettura che di scrittura 

lock in scrittura possono essere declassati a lock in lettura 

i lock in scrittura supportano le variabili condizione 

42 


ReentrantReadWriteLock (2)‏ 

43 


Esempio: ReadWriteLock (1)‏ 

class RWDictionary { 

private final Map m = new TreeMap(); 

private final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock(); 

private final Lock r = rwl.readLock(); 

private final Lock w = rwl.writeLock(); 

public Data get(String key) { 

r.lock(); //lock in lettura per leggere (anche + thread in parallelo) 

try { return m.get(key); } 

finally { r.unlock(); } 

} 

public String[] allKeys() { 

r.lock(); 

try { return m.keySet().toArray(); } 

finally { r.unlock(); } 

} 

… // altri metodi a seguire 

} 

44 


Esempio: ReadWriteLock (2)‏ 

class RWDictionary { 

… 

public Data put(String key, Data value) { 

w.lock(); //una sola scrittura ammessa, non mentre ci sono letture 

try { return m.put(key, value); } 

finally { w.unlock(); } 

} 

public void clear() { 

w.lock(); 

try { m.clear(); } 

finally { w.unlock(); } 

} 

} 

45 


Altri possibili utilizzi 

Accesso controllato ad un file 

46 

Più thread possono accedere in lettura in parallelo (usando 

Stream differenti) ma solo uno in scrittura (per esempio in 

append) 

Utilizzo di aree di memoria condivise 

… 


I Semafori: java.util.concurrent.Semaphore 


Semaphore(int permits) Creates a Semaphore with the given number of permits and 

nonfair fairness setting. 


void 

void 

boolean 

Utilizzati per il controllo di accesso alle risorse 

Utilizzi classici per delimitare codice ad accesso controllato 

47 

int 

acquire(int permits) Acquires the given number of permits from this semaphore, blocking 

until all are available, or the thread is interrupted. 

availablePermits() Returns the current number of permits available 

release(int permits) Releases the given number of permits, … 

tryAcquire(int permits) Acquires the given number of permits from this 

semaphore, only if all are available at the time of invocation. 


48 


Barrier e Latch

java.util.concurrent.CountDownLatches (1)‏ 

A synchronization aid that allows one or more threads to wait until a set of 

operations being performed in other threads completes. 


CountDownLatch(int count) 

Constructs a CountDownLatch initialized with the given count. 


49 

void 

boolean 

void 

long 

String 

await() Causes the current thread to wait until the latch has counted down to zero, unless 

the thread is interrupted. 

await(long timeout, TimeUnit unit) Causes the current thread to wait until the latch has 

counted down to zero, unless the thread is interrupted, or the specified waiting time 

elapses. 

countDown() Decrements the count of the latch, releasing all waiting threads if the count 

reaches zero. 

getCount() Returns the current count. 

toString() Returns a string identifying this latch, as well as its state. 


CountDownLatches (2)‏ 

class Driver { // ... 

void main() throws InterruptedException { 

CountDownLatch startSignal = new CountDownLatch(1); 

CountDownLatch doneSignal = new CountDownLatch(N); 

for (int i = 0; i < N; ++i)//create/start threads 

new Thread( 

new Worker(startSignal,doneSignal)).start(); 

doSomethingElse(); // don't let run yet 

startSignal.countDown();// let all threads proceed 

doSomethingElse(); 

doneSignal.await(); // wait for all to finish 

} 

 

50 

C’è un Driver e diversi thread Worker 

startSignal serve ad impedire che i Worker procedano prima che il 

Driver è pronto 

doneSignal serve al Driver per attendere che tutti i Worker 

abbiano terminato 


CountDownLatches (3)‏ 

class Worker implements Runnable { 

private final CountDownLatch startSignal; 

private final CountDownLatch doneSignal; 

Worker(CountDownLatch startSignal, 

CountDownLatch doneSignal) { 

this.startSignal = startSignal; 

this.doneSignal = doneSignal; 

} 

public void run() { 

try { 

startSignal.await(); 

doWork(); 

doneSignal.countDown(); 

} catch (InterruptedException ex) {}// return; 

} 

void doWork() { ... } 

} 

51 


java.util.concurrent.CyclicBarrier (1)‏ 

Consente di fermare e sincronizzare dei thread presso una 

barriera in attesa che tutti i partecipanti la raggiungono 

Utile per la decomposizione di problemi in sottoproblemi 

da risolvere concorrentemente 


CyclicBarrier(int parties) Creates a new CyclicBarrier that will trip when the given 

number of parties (threads) are waiting upon it, and does not perform a predefined 

action upon each barrier. 

CyclicBarrier(int parties, Runnable barrierAction) Creates a new CyclicBarrier 

that will trip when the given number of parties (threads) are waiting upon it, and 

which will execute the given barrier action when the barrier is tripped, performed by 

the last thread entering the barrier. 

52 


CyclicBarrier (2)‏ 

I sottoproblemi si affidano a thread distinti 

La barriera serve per sincronizzarsi sulla loro fine e ricomporne i risultati 


int 

int 

int 

int 

boolean 

void 53 

await() Waits until all parties have invoked await on this barrier. 

await(long timeout, TimeUnit unit) Waits until all parties have invoked 

await on this barrier. 

getNumberWaiting() the n. of parties currently waiting at the barrier. 

getParties() Returns the n. of parties required to trip this barrier. 

isBroken() Queries if this barrier is in a broken state. 

reset() Resets the barrier to its initial state. 



class Solver { 

final int N; 

final float[][] data; 

final CyclicBarrier barrier; 

 

class Worker implements Runnable { 

int myRow; 

Worker(int row) { myRow = row; } 


while (!done()) { 

processRow(myRow); 

try { barrier.await(); } 

catch (InterruptedException ex){ return; } 

catch (BrokenBarrierException ex){ return;} 

} 

} //… 

54 



//… 

public Solver(float[][] matrix) { 

data = matrix; 

N = matrix.length; 

barrier = 

new CyclicBarrier(N, 

new Runnable() { 


mergeRows(...); 

} 

}); 

for (int i = 0; i < N; ++i) 

new Thread(new Worker(i)).start(); 

waitUntilDone(); 

} 

} 

55 


java.util.concurrent.CompletionService (1)‏ 

Interfaccia che permette di disaccoppiare la 

sottomissione di nuovi task da eseguire, dalla 

consumazione dei corrispondenti risultati 

I risultati sono consumati nell’ordine temporale in cui i 

task sono completati, indipendentemente dall’ordine di 

sottomissione 

56 


CompletionService (2)‏ 


Future 

Future 

Future 

Future 

Future 

57 

poll() Retrieves and removes the Future representing the next 

completed task or null if none are present. 

poll(long timeout, TimeUnit unit) Retrieves and removes the Future 

representing the next completed task, waiting if necessary up to the 

specified wait time if none are yet present. 

submit(Callable task) Submits a value-returning task for 

execution and returns a Future representing the pending results of the 

task. 

submit(Runnable task, V result) Submits a Runnable task for 

execution and returns a Future representing that task.Upon completion, 

this task may be taken or polled. 

take() Retrieves and removes the Future representing the next 

completed task, waiting if PdR_09010 none are - Stefano yet present. Millozzi

java.util.concurrent.ExecutorCompletionService 

Implementazione del CompetitionSercive, agganciato ad 

un Executor 


ExecutorCompletionService(Executor executor) Creates an 

ExecutorCompletionService using the supplied executor for base task execution 

and a LinkedBlockingQueue as a completion queue. 

ExecutorCompletionService(Executor executor, 

BlockingQueue completionQueue) Creates an 

ExecutorCompletionService using the supplied executor for base task execution 

and the supplied queue as its completion queue. 

58 


Esempio: Decomposizione Parallela 

Sono dati un certo numero di Solver per un dato 

problema, ciascuno restituisce un valore di tipo Result 

Si vuole ottenere una soluzione eseguendoli 

concorrentemente 

Il problema si considera risolto non appena si ottiene la 

prima soluzione non nulla 

Si interrompono tutti i risolutori ancora attivi 

Si usano 

59 

ExecutorCompletionService 

Executor 

Future 


Risolutore Concorrente (1)‏ 

void solve(Executor e, 

Collection solvers)‏ 

throws InterruptedException { 

CompletionService ecs = 

new ExecutorCompletionService(e); 

int n = solvers.size(); 

List futures = new 

ArrayList(n); 

Result result = null; 

// esecuzione concorrente dei solver a seguire 

if (result != null)‏ 

use(result); // utilizzo del risultato 

} 

60 


Risolutore Concorrente (2)‏ 

… 

for (Callable s : solvers)‏ 

futures.add(ecs.submit(s)); 

for (int i = 0; i < n; ++i) { 

try { Result r = ecs.take().get(); 

if (r != null) { 

result = r; 

break; 

} 

} catch(ExecutionException ignore) {} 

} 

} 

finally { 

for (Future f : futures)‏ 

f.cancel(true); 

} 

// utilizzo di result 

61

Progetto di reti di Calcolatori e Sistemi Informativi

Create successful ePaper yourself

Delete template?

Save as template?