Ministerul Educaţiei al Republicii Moldova

Universitatea Tehnică a Moldovei

Facultatea Calculatoare, Informatică şi Microelectronică

RAPORT
La lucrarea de laborator nr.2

Disciplina: Programarea în rețea

Tema: Programarea multi-threading

A elaborat st. gr. TI-171 FR, Socolicov

Valeria

A verificat lector. univ., Aurel

Zgureanu
Chișinău 2021

2
Obiectivele lucrării
Înțelegerea modelelor de execuție concurentă și cunoașterea tehnicilor esențiale de
sincronizare ale activităților bazate pe operațiile atomare ale semaforului; obiectivul specific
constând în crearea unei aplicații Java ce ar utiliza sigur diverse structuri într-un context de
execuție concurentă.

Sarcini tip pentru lucrarea de laborator

Sarcina lucrării de laborator cuprinde o diagramă a dependențelor cauzale, care definește
o mulțime de evenimente (activități) ordonate de relații de cauzalitate (figura 1). în esență
această diagramă este un graf orientat aciclic, în care evenimentele sunt reprezentate prin noduri,
iar dependențele cauzale prin arcuri.
Notă: Fiecare student alege diagrama în funcție de numărul de ordine n din lista de
registru în conformitate cu regula:
diagrama a) – pentru n care satisface relația n mod 4 = 0
diagrama b) – pentru n care satisface relația n mod 4 = 1
diagrama c) – pentru n care satisface relația n mod 4 = 2
diagrama d) – pentru n care satisface relația n mod 4 = 3
unde a mod b însemnă restul împărțirii lui a la b.
Confirm regulei, s-a îndeplinit sarcina după diagrama a.

Clasa pricipală de monitorizare a evinimentelor utilizată

Class CountDownLatch
java.lang.Object
java.util.concurrent.CountDownLatch
public class CountDownLatch
extends Object

3
 Un ajutor de sincronizare care permite unuia sau mai multor fire să aștepte până la
finalizarea unui set de operații efectuate în alte fire.
Un CountDownLatch este inițializat cu un număr . Metodele de așteptare se blochează
până când numărul curent ajunge la zero din cauza invocațiilor metodei countDown (), după care
sunt eliberate toate firele de așteptare și orice invocații ulterioare de aștepta revin imediat. Acesta
este un fenomen unic - numărul nu poate fi resetat.
Un CountDownLatch este un instrument de sincronizare versatil și poate fi utilizat în mai
multe scopuri. Un CountDownLatch inițializat cu un număr de unul servește ca un simplu zăvor
on / off, sau poartă: toate firele care invocă așteaptă la poartă până când este deschis de un fir
care invocă countDown (). Un CountDownLatch inițializat la N poate fi folosit pentru a face un
fir să aștepte până când N fire au finalizat o acțiune sau o acțiune a fost finalizată de N ori.
O proprietate utilă a unui CountDownLatch este că nu necesită ca firele care apelează
countDown să aștepte ca numărul să ajungă la zero înainte de a continua, pur și simplu împiedică
orice fir să treacă peste o așteptare până când toate firele ar putea trece

Mai jos teste reprezentat codul sursă:

import java.util.concurrent.*;
import java.util.*;
import java.text.*;

public class Lab2 {

public static void main(String[] args) throws Exception {

System.out.println("Labrotatorul nr2, Varianta 20 a) \n");
System.out.println("Start Executie fire \n");
var t1 = new Worker("Fir 1", getRandomNumber(1000,2000));
var t2 = new Worker("Fir 2", getRandomNumber(1000,2000));
var t3 = new Worker("Fir 3", getRandomNumber(1000,2000));
var t4 = new Worker("Fir 4", getRandomNumber(1000,2000));
var t5 = new Worker("Fir 5", getRandomNumber(1000,2000));
var t6 = new Worker("Fir 6", getRandomNumber(1000,2000));
var t7 = new Worker("Fir 7", getRandomNumber(1000,2000));
t2.waitWorkers(new Worker[]{t1});
t3.waitWorkers(new Worker[]{t1});
t4.waitWorkers(new Worker[]{t1});
t5.waitWorkers(new Worker[]{t2});
t6.waitWorkers(new Worker[]{t3});
t7.waitWorkers(new Worker[]{t4});

Worker[] workers = { t1, t2, t3, t4, t5, t6, t7};

for (Worker worker : workers) { worker.run(); }
}
public static int getRandomNumber(int min, int max) {
return (int) ((Math.random() * (max - min)) + min);
}
}

4
public class Worker
{
private CountDownLatch _countdown;
private ArrayList<Worker> _waiters;
private int _workersWait;
private int timeout;
private Thread thread;
public String name;
public Worker(String name, int timeout)
{
this.name = name;
this.timeout = timeout;
_countdown = new CountDownLatch(1);
_waiters = new ArrayList<Worker>();
thread = new Thread("Fir nou") {
public void run(){
release();
}
};
}
public void run()
{
thread.start();
}

public void waitWorkers(Worker[] workers)

{
getIsRunning();

for(Worker threadM : workers)

{
if (threadM == this || threadM._waiters.contains(this)) continue;
threadM._waiters.add(this);
_workersWait++;
}

private void getIsRunning()

{
if (thread.getState() == Thread.State.RUNNABLE)
{
System.out.println("Fir-ul deja e pornit :" + this.name);
}
}

private void release()

{
try
{
_countdown = new CountDownLatch(_workersWait);
_countdown.await();
System.out.println(this.name + " in statut pornit");
Thread.sleep(timeout);
}
catch (InterruptedException exc)
{
System.out.println(exc);
}
finally
{

5
 for (Worker waiter : _waiters)
{
waiter._countdown.countDown();
}
}
}
}

Rezultatul execuției:
La execuția codului, afișarea rezultatului va fi mereu diferit în ceea ce ține de ordinea
firelor 2,3,4 și 5,6 7. Aceasta este provocată de faptul că firele 2,3,4 mereu o să aștepte firul 1,
deci primul mereu va fi 1, iar următoarele random se vor porni 2,3,4. După ideea aceasta se vor
afișa și următoarele fire, 5,6,7 ce deja vor fi dependente de firele 2,3,4 conform pornirii acestora.
Rezultatul:

Concluzie
În urma realizarii lucrării de laborator am dobîndit cunoștințe practice în lucrul cu firele
de execuție și controlul lor de execuție. Deasemenea în timpul efectuării sarcinii am identificat
notele de curs referitor la metoda de sincronizare CountDown, cum ar fi absența metodei de
resetare în java.