Java Professional

Curs 4
 Fire de executie

Un fir de executie este un set de instructiuni care se executa individual si independent

fata de alte seturi de instructiuni din aplicatie.

Aplicatie cu un singur fir de executie: single Threded

Aplicatie cu mai multe fire de executie: multithreded
Putem porni mai multe fire de executie in paralel.

Crearea unui fir de executie:

1. O clasa care mosteneste clasa Thread
2. Folosirea interfetei Runnable (interfata functionala) -> decupleaza codul
 Am creat o instanta, dar nu am
pornit firul de executie

new

start()

Firul de executie poate fi Firul de executie

RUNNABLE RUNNING se ruleaza
pus in executie de catre
masina virtuala.

BLOKED DEAD

Firul de executie este Firul a terminat ce a avut

ascuns de masina virtulala de facut sau a fost
intrerupt
Executors API
Este un set de clase specializate in managementul mai multor fire de
executie si in executarea unei cozi de taskuri.
java.util.concurrent

• interfata Executor
• interfata ExecutorService : un Executor care vine in plus cu functionalitati de
executare a mai multor task-uri deodata, de obtinere a unui rezultat in urma unui
task, etc.
• intefata ScheduledExecutorService : un ExecutorService care vine in plus cu
functionalitatea de a executa un task cu delay sau de a executa un task in mod
repetat
• clasa utilitara Executors : este clasa care ofera implementari pentru interfetele
mentionate mai sus

task -> Instanta de Runnable sau Callable

ExecutorService service = Executors.newFixedThreadPool(x); -> va creea un thread
pool cu un numar fix de x fire de executie;

ExecutorService service = Executors.newSingleThreadExecutor(); -> va crea un singur

thread

ExecutorService service = Executors.newCachedThreadPool(); -> va crea un executor

cu un numar variabil de fire de executie in functie de taskurile in asteptare. Reduce
automat numarul de fire de executie din pool daca sunt prea multe

ScheduledExecutorService service = Executors.newSingleThreadScheduledExecutor();

-> creaza un executor cu fire de executie programare
 Runnable Callable
public interface Runnable { public interface Callable<V> {
public void run(); V call() throws Exception;
} }
Nu poti propaga exceptii Poti propaga exceptii

Nu returneaza nimic Returneaza o valoare. Instanta este

preluata de un obiect de Future.

service.execute(task) Future<V> future = service.submit(task);

Obiecte blocante
• java.util.concurrent.Semaphore
• Putem folosi un “Semafor” pentru a limita numarul de fire de executie
concurente care acceseaza o anumita resursa.
• Semaphore semaphore = new Semaphode(x);
X-> numarul de fire de executie care pot accesa resursa

semaphore.acquire() -> marcheaza inceputul blocului sincronizant

semaphore.release() -> marcheaza sfarsitul blocului sincronizant

• java.util.concurrent.loks.ReentrantReadWriteLock
• ReentrantReadWriteLock contine doua lokuri -> unul de read unul de write

• Lock readLock() – returneaza un lock folosit pentru citit

• Lock writeLock() – returneaza un lock folosit pentru scris
• java.util.concurrent.CyclicBarrier

CyclicBarrier barrier = new CyclicBarrier(x) -> creaza o bariera care nu lasa sa

treaca mai multe fire de executie decat x;

barrier.await() -> pune firele de executie in asteptare pana cand se strang cele x
fifre de executie
• java.util.concurrent.atomic.AtomicInteger

Sunt clase care impacheteaza: primitive, array-uri, tipuri referinta, si care vin cu
metode care implementeaza un set de operatii pe tipul respectiv intr-un mod
sincroniza

Ex.: AtomicInteger x = new AtomicInteger(initialValue);

x.incrementAndGet()