Crearea firelor de

execuție
 Definiția thread-urilor
 Firele de execuție reprezintă mecanismul prin care pot fi
implementate în cadrul unui program secvențe de cod ce
se execută virtual în paralel.
 Trebuie făcută distincție între fire de execuție și procese.
Deși ambele concepte implică execuția în paralel a unor
secvențe de cod există o serie de deosebiri fundamentale
între procese și fire de execuție. Procesele sunt entități
independente ce se execută independent și sunt
gestionate de către nucleul sistemului de operare. Firele
de execuție sunt secvențe ale unui program (proces) ce
se execută aparent în paralel în cadrul unui singur
proces.
 Construirea și startarea thread-urilor
 Java implementează mecanismele necesare pentru a
inițializa și executa un fir de execuție este clasa Thread.
Pentru a construi un fir de execuție trebuie extinsă
 clasa Thread și suprascrisă metoda run() din cadrul
acestea. În cadrul metodei run() se va implementa
secvența de instrucțiuni ce se va executa în momentul în
care un fir de execuție este startat.
 Pentru a lansa în execuție un fir se folosește metoda
start() (moștenită de asemenea din cadrul clasei Thread).
Această metodă este responsabilă cu inițializarea tuturor
mecanismelor necesare pentru a putea executa un fir de
execuție, după care va apela automat metoda run().
Metodele de creare a thread-urilor

 1. Clasa Thread
 O modalitate de a crea şi lansa in execuţie
fire (de execuţie ) este de a folosi clasa
Thread din pachetul java.lang:
 Public class Thread1extends Thread
 Pentru a crea un fir de execuţie , trebuie
să cream un obiect de tipul Thread:
 Thread fir=new Thread();
 2. Interfața Runnable constituie o
alternativă la extinderea clasei Thread.
 Avantajul constă in primul rând în însusi
faptul că este o interfaţă: o clasă oarecare
poate implementa Runnable şi extinde o
altă clasă (pe când o clasă ce extind
Thread nu mai poate extinde vreo altă
clasă).
 public class Thread11 extends Objects11
implements Runnable
Crearea thread-urilor utilizînd clasa Thread
public class SimpleThread extends Thread {
private int countDown = 5;
private static int threadCount = 0;
private int threadNumber = ++threadCount;
public SimpleThread() {
System.out.println("Making " + threadNumber); }
public void run() {
while(true)
{ System.out.println("Thread " + threadNumber + "(" +
countDown + ")");
if(--countDown == 0) return;
}}
public static void main(String[] args) {
for(int i = 0; i < 5; i++)
new SimpleThread().start();
System.out.println("All Threads Started");
}}
Rezultatul realizării:
Making 1 Thread 5(4)
Thread 1(3)
Making 2 Thread 4(3)
Thread 1(5) Thread 2(3)
Making 3 Thread 3(3)
Thread 2(5) Thread 5(3)
Making 4 Thread 1(2)
Making 5 Thread 4(2)
Thread 4(5) Thread 2(2)
All Threads Started Thread 3(2)
Thread 3(5) Thread 5(2)
Thread 5(5) Thread 1(1)
Thread 1(4) Thread 4(1)
Thread 2(4) Thread 2(1)
Thread 4(4) Thread 5(1)
Thread 3(4) Thread 3(1)
 Utilizarea interfeții Runnable
class ThreadR implements Runnable
{ int count =5;
public String toString(){
return "- "+Thread.currentThread().getName()+ " "+count;}
public void run(){
while (true) {
System.out.println(this);
if (--count==0) return;
}}}
public class ThredRun {
public static void main(String[ ]args)
{ for(int i=0; i<5; i++)
new Thread(new ThreadR()).start();
}}
 Rezultatul realizarii
 run:
 - Thread-0 5
 - Thread-0 4
 - Thread-0 3
 - Thread-0 2
 - Thread-0 1
 - Thread-1 5
 - Thread-1 4
 - Thread-1 3
 - Thread-1 2
 - Thread-1 1
 - Thread-2 5
 - Thread-2 4
 - Thread-2 3
 - Thread-2 2
 - Thread-2 1
 - Thread-4 5
 - Thread-4 4
 - Thread-4 3
 - Thread-4 2
 - Thread-4 1
 - Thread-3 5
 - Thread-3 4
 - Thread-3 3
 - Thread-3 2
 - Thread-3 1