class testThread extends Thread class testRunnable implements Runnable

{ {
int id; //fiecare thread va avea numar propriu int id; //fiecare thread va avea numar propriu

testThread() //constructor implicit testRunnable () //constructor implicit

{ {
id = -10; id = -100;
} }

testThread(int x) //constructor cu parametru testRunnable (int x) //constructor cu parametru

{ {
id = x; id = x;
} }

public void run() //metoda principala a firului (analog public void run() //metoda principala a firului (analog
{ // metodei main pentru fir de executie) { // metodei main pentru fir de executie)
System.out.println(“Thread nr ”+ id); System.out.println(“Thread nr ”+ id);
} }

} }

class Main
{
public static void main(String a[])
{
///////////////////////////////// crearea si lansarea firului de tip Thread ///////////////////////////////////////////////////////

testThread oblectThread1 = new testThread(); //crearea firului de executie de tip Thread

objectThread1.start(); //lansarea firului de executie de tip Thread (start lanseaza run pentru acest fir)
// putem chema start pentru acest obiect, pentru ca clasa testThread are metoda start mostenita de la clasa parinte Thread

///////////////////////////////// analog creerii si lansarii firului de tip Thread, utilizand noname object ////////////////////////

(new testThread()).start();

///////////////////////////////// crearea si lansarea firului de tip Runnable ///////////////////////////////////////////////////////

testRunnable oblectRunnable1 = new testRunnable(); //crearea firului de executie de tip Thread

objectRunnable1.start(); //nu putem chema start pentru acest obiect, pentru ca clasa testRrunnable nu are start
Thread tempThread = new Thread(oblectRunnable1);
// creem obiect temporar de tip Thread pe baza obiectului de tip Runnable (utilizam constructor Thread (Runnable r) )

tempThread.start(); //acest obiect poate fi lansat deoarece clasa Thread are metoda start.
///////////////////////////////// analog creerii si lansarii firului de tip Runnable, utilizand noname object ////////////////////////
 (new Thread (new testRunnable())).start();

///////////////////////////////// crearea si lansarea multimii de fire de tip Thread /////////////////////////////////////////////////

testThread vectorThread[] = new testThread[10];

for(int i=0; i<10; i++)
{
vectorThread[i] = new testThread(i);
testThread(i).start();
}
///////////////////////////////// utilizand noname object ///////////////////////////////////////////////////////////////////////

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

(new testThread(i)).start();

///////////////////////////////// crearea si lansarea multimii de fire de tip Runnable /////////////////////////////////////////////////

testThread vectorRun[] = new testRunnable[20];

for(int i=0; i< vectorRun.length; i++)
{
vectorRun[i] = new testRunnable(i);
Thread tempThread = new Thread(vectorRun[i]);
testThread(i).start();
}
///////////////////////////////// utilizand noname object ///////////////////////////////////////////////////////////////////////

for(int i=0; i< vectorRun.length; i++)

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

}
}
 Exemplu pentru lab5

Formularea conditiei: Se da o matrice de tip int. De separate matricia pe randuri, fiecare rand se prelucreaza de fir de
executie propriu. Fiecare fir calculeaza suma elementelor in rand propriu. In metoda main de afisat suma rezultatelor
firelor, deci suma tuturor elementelor matriciei. De mostenit clasa de la Thread.
Import java.util.*;
class A
{
static int A[][];
static int rinduri, coloane, sumaGlobala;
int idPropriuFirului;

static{
rinduri = (new Random()).nextInt(10)+1;
coloane = (new Random()).nextInt(10)+1;
A = new int[rinduri][coloane]
for( int r = 0; r < rinduri; r ++)
for( int c = 0; c < coloane; c ++)
A[r][c] = (new Random()).nextInt(20) - 10;
sumaGlobala = 0;
}
void afisareaMatriciei()
{
for( int r = 0; r < rinduri; r ++)
{
for( int c = 0; c < coloane; c ++)
System.out.print(“ “+A[r][c]);
System.out.println();
}
}
A(int x)
{
idPropriuFirului = x;
 }

public void run()

{
int sumaLocalaRindului = 0;
for ( int i = 0; i < coloane; i++)
sumaLocalaRindului += A[idPropriuFirului][i];

System.out.println(“Fir de executie nr. ”+idPropriuFirului+ “ are suma randului = ”+sumaLocalaRindului);

sumaGlobala +=sumaLocalaRindului;
}
public static void main (String a[])
{
afisareaMatriciei();
for ( int i = 0; i < rinduri; i++)
(new A(i)).start();

try{ Thread.sleep(1000); } catch(InterruptedException u){};

System.out.println(“Suma elementelor matriciei = ”+ sumaGlobala);
}
}