OS105

Capitolul 5: Fire de Execuţie Procese Simple şi Multi-fir
 Descriere
 Modele de Multithreading
 Probleme asociate Firelor de Execuţie
 Pthreads
 Thread-uri Windows XP
 Thread-uri Linux
 Thread-uri Java
Operating System Concepts with Java 5.1 Silberschatz, Galvin and Gagne ©2003 Operating System Concepts with Java 5.2 Silberschatz, Galvin and Gagne ©2003
Beneficii Fire Utilizator

 Responsivitate  Gestionarea firelor de execuţie realizată prin librării de nivel
utilizator
 Partajarea resurselor
 Cele mai răspândite librării de fire de execuţie:
 Economie  Firele POSIX - Pthread
 Firele Java
 Utilizarea arhitecturilor Multi-Procesor  Firele Win32
Fire de Execuţie de nivel nucleu Modele de Multithreading

 Sprijinite de nucleu  Multe-la-Una
 Exemple  Unu-la-Unu
 Windows XP/2000
 Solaris  Multe-la-Multe
 Linux
 Tru64 UNIX
 Mac OS X
1
Multe-la-Una Modelul Multe-la-Una
 Multe fire de nivel utilizator mapate pe un singur fir de nivel
nucleu
 Exemple
 Solaris Green Threads
 GNU Portable Threads
Unu-la-Unu Modelul Unu-la-Unu

 Fiecare fir de nivel utilizator se mapează pe un fir nucleu
 Exemple
 Windows NT/XP/2000
 Linux
 Solaris 9 şi variante mai noi
Modelul Multe-la-Multe Modelul Multe-la-Multe

 Permite ca mai multe fire de nivel utilizator să fie mapate pe mai
multe fire de nivel nucleu
 Permite ca sistemul de operare să creeze un număr suficient de
fire nucleu
 Solaris înainte de versiunea 9
 Windows NT/2000 cu pachetul ThreadFiber
2
Modelul pe două nivele Modelul pe două nivele
 Similar cu M:M, cu excepţia că permite ca un fir utilizator să fie
legat de un fir nucleu
 Exemple
 IRIX
 HP-UX
 Tru64 UNIX
 Solaris 8 şi mai vechi
Probleme asociate Firelor de Execuţie Semantica fork() şi exec()

 Semantica apelurilor sistem fork() şi exec()  fork() duplică doar firul apelant sau toate firele?
 Anularea firului
 Manipularea semnalelor
 Plaja de fire (Thread pools)
 Date specifice firelor
 Activarea planificatorului
Anularea unui fir Manipularea Semnalelor

 Terminarea unui fir înainte de a se fi terminat  Semnalele sunt folosite în sistemele UNIX pentru a notifica un
 Există două abordări: proces despre apariţia unui anumit eveniment
 Anularea asincronă termină firul ţintă imediat  O funcţie de tratare a unui semnal este folosit pentru a procesa
semnalul
 Anulare amânată permite ca firul ţintă să verifice periodic dacă ar
trebui să fie anulat 1. Semnalul poate fi generat de un anumit eveniment
2. Semnalul este livrat unui proces
3. Semnalul este tratat
 Opţiuni:
 Livrează semnalul firului căruia semnalul se aplică
 Livrează semnalul fiecărui fir din proces
 Livrează semnalul anumitor fire din proces
 Desemnează un fir specific pentru a recepţiona toate semnalele
pentru proces
3
Plaja de Fire Date specifice firului
 Creează un număr de fire într-o plajă unde ei aşteaptă de lucru  Permite ca fiecare fir să aibe propria copie a datelor
 Avantaje:  Folositoare când nu există controlul asupra procesului de creare
 De obicei puţin mai rapid în satisfacerea unei cereri printr-un fir a firului (ex., când se foloseşte o plajă de fire)
existent decât prin crearea unui fir nou
 Permite ca numărul de fire din aplicaţie/aplicaţii să fie legat de
dimensiunea plajei
Activarea Planificatorului Pthreads

 Ambele modele M:M şi pe două nivele necesită comunicare  Un API standard POSIX (IEEE 1003.1c) pentru crearea şi
pentru a păstra numărul potrivit de fire nucleu alocate aplicaţiei sincronizarea de fire de execuţie
 Activarea planificatorului oferă “apeluri în sus” upcalls – un  API-ul specifică comportarea librăriei de fire de execuţie,
mecanism de comunicare de la nucleu la librăria de fire implementarea este după bunul plac al dezvoltatorului librăriei
 Această comunicare permite ca o aplicaţie să păstreze numărul  Obişnuit în sistemele de operare UNIX (Solaris, Linux, Mac OS
corect de fire nucleu X)
Pthreads Fire Windows XP

int sum; /* aceasta data este partajata de fir(e) */
void *runner(void *param); /* firul */
 Implementează maparea Unu-la-Unu
main(int argc, char *argv[])
{  Fiecare fir conţine
pthread_t tid; /* identificatorul firului */  Un id de fir
pthread_attr_t attr; /* set de atribute pentru fir */
/* preia atributele implicite */  Un set de regiştri
pthread_attr_init(&attr);
/* creaza firul */  Stive utilizator şi nucleu separate
pthread_create(&tid,&attr,runner,argv[1]);
/* acum asteapta ca firul sa se termine */  Zonă privată de stocare pentru date
pthread_join(tid,NULL);
printf("sum = %d\n",sum);
 Setul de regiştri, stivele şi zona privată sunt cunoscute ca şi
} context al firelor
void *runner(void *param) {  Structurile de date primare ale unui fir includ:
int upper = atoi(param);
int i;  ETHREAD (executive thread block)
sum = 0;  KTHREAD (kernel thread block)
if (upper > 0) {
for (i = 1; i <= upper; i++)  TEB (thread environment block)
sum += i;
}
pthread_exit(0);
}
4
Fire Linux Fire Java
 Linux se referă la ele ca şi task-uri în loc de fire (threads)
 Crearea de fire este realizată prin apelul sistem clone()  Firele Java sunt gestionate de către JVM
 clone() permite ca un task fiu să partajeze spaţiul de adrese al
task-ului (procesului) părinte  Firele Java pot fi create prin:
 Extinderea clasei Thread

 Implementarea interfeţei Runnable
Extinderea clasei Thread Interfaţa Runnable

class Worker1 extends Thread public interface Runnable
{
{
public void run() {
System.out.println(“Eu sunt un fir de lucru"); public abstract void run();
} }
}
public class First

{
public static void main(String args[]) {
Worker1 runner = new Worker1();
runner.start();
System.out.println(“Eu sunt firul principal");

}
}
Implementarea interfeţei Runnable Stările Firelor Java
class Worker2 implements Runnable

{
public void run() {
System.out.println(“Eu sunt un fir de lucru");
}
}
public class Second
{
Runnable runner = new Worker2();
Thread thrd = new Thread(runner);
thrd.start();
System.out.println(“Eu sunt firul principal");

}
}
5
Joncţiunea Firelor Anularea Firului
class JoinableWorker implements Runnable
{
public void run() {
System.out.println(“Lucratorul lucreaza"); Thread thrd = new Thread (new InterruptibleThread());
} Thrd.start();
}
...
public class JoinExample
{ // Acum sa il intrerupem
public static void main(String[] args) { Thrd.interrupt();
Thread task = new Thread(new JoinableWorker());
task.start();
try { task.join(); }
catch (InterruptedException ie) { }
System.out.println(“Lucratorul a terminat");
}
}
Anularea unui Fir Date specifice unui fir
public class InterruptibleThread implements Runnable class Service

{ {
public void run() { private static ThreadLocal errorCode = new ThreadLocal();
while (true) {
/** public static void transaction() {
* Efectueaza ceva pentru un timp try {
*/ /**
* ceva operatii unde ar putea aparea o eroare
if (Thread.currentThread().isInterrupted()) { */
System.out.println(“Sunt intrerupt!"); catch (Exception e) {
break; errorCode.set(e);
} }
} }
// Fa curatenie si termnina /**

} * preia codul de eroare pentru aceasta tranzactie
} */
public static Object getErrorCode() {
return errorCode.get();
}
}
Date specifice unui fir Problema Producător-Consumator
public class Factory

class Worker implements Runnable {
{ public Factory() {
private static Service provider; // prima oara creem buffer-ul de mesaje
Channel mailBox = new MessageQueue();
public void run() {
provider.transaction(); // acum cream firele producator si consumator
System.out.println(provider.getErrorCode()); Thread producerThread = new Thread(new Producer(mailBox));
} Thread consumerThread = new Thread(new Consumer(mailBox));
}
producerThread.start();
consumerThread.start();
}

Factory server = new Factory();
}
}
6
Firul Producator Firul Consumator
class Producer implements Runnable class Consumer implements Runnable

{ {
private Channel mbox; private Channel mbox;
public Producer(Channel mbox) { public Consumer(Channel mbox) {

this.mbox = mbox; this.mbox = mbox;
} }
public void run() { public void run() {

Date message; Date message;
while (true) { while (true) {

SleepUtilities.nap(); SleepUtilities.nap();
message = new Date(); // consuma un element din buffer
System.out.println(“Producatorul a produs " + message); System.out.println(“Consumatorul vrea sa consume.");
// produce un element si insereaza-l in buffer message = (Date)mbox.receive();

mbox.send(message); if (message != null)
} System.out.println(“Consumatorul a consumat " + message);
} }
} }
}

OS105

Încărcat de

Informații document

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

OS105

Încărcat de

Drepturi de autor:

Formate disponibile

Capitolul 5: Fire de Execuţie Procese Simple şi Multi-fir

Beneficii Fire Utilizator

Fire de Execuţie de nivel nucleu Modele de Multithreading

Unu-la-Unu Modelul Unu-la-Unu

Modelul Multe-la-Multe Modelul Multe-la-Multe

Probleme asociate Firelor de Execuţie Semantica fork() şi exec()

Anularea unui fir Manipularea Semnalelor

Activarea Planificatorului Pthreads

Pthreads Fire Windows XP

 Extinderea clasei Thread

Extinderea clasei Thread Interfaţa Runnable

public class First

System.out.println(“Eu sunt firul principal");

Implementarea interfeţei Runnable Stările Firelor Java

class Worker2 implements Runnable

System.out.println(“Eu sunt firul principal");

Anularea unui Fir Date specifice unui fir

public class InterruptibleThread implements Runnable class Service

// Fa curatenie si termnina /**

Date specifice unui fir Problema Producător-Consumator

public class Factory

public static void main(String args[]) {

class Producer implements Runnable class Consumer implements Runnable

public Producer(Channel mbox) { public Consumer(Channel mbox) {

public void run() { public void run() {

while (true) { while (true) {

// produce un element si insereaza-l in buffer message = (Date)mbox.receive();

S-ar putea să vă placă și