Download - Fire de Executie

Transcript
  • Fire de execuie

  • Procese

    Orice aplicaie (Java) ruleaz n interiorul unui proces al sistemului de operare.

    Un proces este un program in executie, care are propriul sau spatiu de adrese in memorie.

    Un proces const din segmente de cod i segmente de date mapate ntr-un spaiu virtual de adresare.

    Fiecare proces deine un numr de resurse alocate de ctre sistemul de operare, cum ar fi fiiere deschise, regiuni de memorie alocate dinamic, sau fire de execuie. Resursele deinute de ctre un proces sunt eliberate la terminarea procesului de ctre sistemul de operare.

    Un sistem de operare multi-tasking permite executia mai multor procese in acelasi timp, fie impartind timpul CPU intre aceste procese (in cazul in care

    calculatorul are un singur CPU) fie gestionand mai multe CPU pentru

    executia proceselor.

  • Fire de executie (threads)

    Multithreading nseamn capacitatea unui program de a executa mai multe secvene de cod n acelai timp.

    O astfel de secven de cod se numete fir de execuie sau thread

    Firele de executie (threads) reprezinta portiuni de cod ale aceluiasi program care se pot executa in paralel una fata de alta.

    Un fir de execuie este unitatea de execuie a unui proces.

    Fiecare fir de execuie are asociate o secven de instruciuni, un set de regiitri CPU i o stiv.

    Un proces nu execut instruciuni - este de fapt un spaiu de adresare comun pentru unul sau mai multe fire de execuie. Execuia instruciunilor cade n responsabilitatea firelor de execuie.

  • Starile unui fir de executie

    Un fir de execuie se poate afla la un moment dat ntr-una din

    urmtoarele stri:

    running (ruleaz),

    waiting (adormire, blocare, suspendare),

    ready (gata de execuie, prezent n coada de

    ateptare),

    dead (terminat).

  • Cum se lucreaza cu firele de executie

    Limbajul Java suport multithreading prin clase disponibile

    n pachetul java.lang.

    Exist 2 metode pentru crearea unui fir de execuie; se creeaz :

    Extinderea clasei Thread o clas derivat din clasa Thread,

    sau

    Implementarea interfeei Runnable o clas care implementez interfaa Runnable.

  • class FirNou extends Thread {

    public FirNou(String nume) {

    // apeleaz constructorul din Thread

    super(nume);

    }

    @Override

    public void run() {

    while (true) { // fr sfrit

    System.out.println(getName() + " Tastati ^C");

    }

    }

    }

    public class TestFirNou { public static void main(String[] args) { new FirNou("Primul").start(); } }

    Extinderea clasei Thread

  • Thread public class FirThread extends Thread { @Override public void run() { // aceasta metoda se execut concurent while (true) { System.out.println("Iar eu sunt un firicel"); } } public static void main(String[] arg) { FirThread fir = new FirThread(); fir.start(); // pornim firul f while (true) { System.out.println("eu sunt firul principal"); } } }

    Iar eu sunt un firicel Iar eu sunt un firicel Iar eu sunt un firicel eu sunt firul principal eu sunt firul principal eu sunt firul principal eu sunt firul principal Iar eu sunt un firicel Iar eu sunt un firicel Iar eu sunt un firicel Iar eu sunt un firicel Iar eu sunt un firicel

  • Implementarea interfeei Runnable

    class ClasaMeadeBaza {

    // ..

    }

    class UnFirNou extends ClasaMeadeBaza implements Runnable {

    @Override

    public void run() {

    for (int i = 0; i < 100; i++) {

    System.out.println("pasul " + i);

    }

    }

    }

    public class DemoFirRunnable {

    public static void main(String argumente[]) {

    new Thread(new UnFirNou()).start();

    // Obiectul este creat i folosit imediat

    for(int i=0;i

  • Prioritatea firelor de execuie

    Fiecare fir de execuie are o prioritate cuprins ntre valorile MIN_PRIORITY i MAX_PRIORITY (variabile finale declarate n clasa Thread ).

    n mod normal un fir de execuie are prioritatea NORM_PRIORITY

    Mediul de execuie Java planific firele de execuie la controlul unitii centrale n funcie de prioritatea lor. Dac exist mai multe fire cu prioritate maxim, acestea sunt planificate dup un algoritm round-robin.

    Firele de prioritate mai mic intr n calcul doar atunci cnd toate firele de prioritate mare sunt n starea Nu Ruleaz .

    Prioritatea unui fir de execuie se poate interoga cu metoda getPriority care ntoarce un numr ntreg care reprezint prioritatea curent a firului de execuie.

    Pentru a seta prioritatea, se folosete metoda setPriority care primete ca parametru un numr ntreg care reprezint prioritatea dorit

  • Metode

    init() - apelata la prima lansare a unui fir de executie, locul unde se scrie codul de initializare

    start()- apelata la fiecare lansare, dupa operatiile de initializare stop()- apelata la terminarea firului de executie, contine codul de

    terminare a unui fir de executie abandonata run()- apelata de metoda start, contine corpul firului de executie Denumirea firelor de executie Thread myThread = new Thread(this.Nume fir) myThread.getName() myThread.setName()

  • Sectiune critica

    Critical Section is some shared state (or memory) that may be simultaneously accessed and changed by different processes. Failure to properly synchronize leads to inconsistent state or a race conditions.

  • Excludere mutual

    Excluderea mutuala: reprezinta operatia multitasking prin care se permite accesul unui singur task in propria sectiune critica referitoare la o resursa.

    1-orice sectiune critica referitoare la o resursa poate fi executata la un moment dat de catre un singur task.

    2-nu se poate face nici o predictie in ceea ce priveste frecventa si viteza de executare a taskului

    3-orice task are dreptul sa acceseze pt un timp finit propriile secvente critice

    4-orice task are obligatia sa elibereze sectiunea critica dupa un anumit interval de timp

    5-taskurile nu se pot bloca in interiorul sectiunilor critice

  • Sincronizare

    in situatiile in care doua sau mai multe fire acceseaza o resursa comuna acestea trebuie sa -i sincronizeze accesul la acea resursa

    synchronized void f() { /* ... */ }

    Att timp cat metoda sincronizata este in execuie nici o alta metoda

    sincronizata nu va mai putea fi apelata de ctre un alt fir.

    Fiecare obiect are inclus automat un monitor (sau un zvor).

    In momentul in care un fir ncearc sa acceseze o metoda sincronizata a unui obiect care are monitorul acaparat de ctre un alt fir, acesta se blocheaz in ateptarea eliberrii monitorului.

  • wait, notify, join

    Metodele wait() si notify() sunt utilizate pentru a bloca i debloca firele de execuie.

    cele dou metode fac parte din clasaObject - manipuleaz monitoarele obiectelor, si, la rndul lor, monitoarele se gsesc la nivelul oricrui obiect.

    Metodele wait si notify pot fi apelate doar din interiorul unor blocuri sau metode sincronizate. Ceea ce inseamn ca aceste metode, pentru un obiect data, pot fi apelate doar de ctre deintorul monitorului obiectului.

    In momentul in care un fir este blocat prin apelarea metodei wait()

    monitorul deinut de respectivul fir este eliberat.

    Metoda join() aparine clasei Thread si este utilizata pentru a determina un fir de execuie s atepte terminarea unui alt fir de execuie.

  • deadlock, livelock

    a deadlock is a situation in which two or more competing actions are each waiting for the other to finish, and thus neither ever does.

    A livelock is similar to a deadlock, except that the states of the processes involved in the livelock constantly change with regard to one another, none progressing.

    http://en.wikipedia.org/wiki/Deadlock

  • Producator-Consumator private void produce(int i) throws InterruptedException {

    //wait if queue is full

    while (sharedQueue.size() == SIZE) {

    synchronized (sharedQueue) {

    System.out.println("Queue is full " + Thread.currentThread().getName()

    + " is waiting , size: " + sharedQueue.size());

    sharedQueue.wait();

    }

    }

    //producing element and notify consumers

    synchronized (sharedQueue) {

    sharedQueue.add(i);

    sharedQueue.notifyAll();

    }

    }

  • Producator-Consumator private int consume() throws InterruptedException {

    //wait if queue is empty

    while (sharedQueue.isEmpty()) {

    synchronized (sharedQueue) {

    System.out.println("Queue is empty " + Thread.currentThread().getName()

    + " is waiting , size: " + sharedQueue.size());

    sharedQueue.wait();

    }

    }

    //Otherwise consume element and notify waiting producer

    synchronized (sharedQueue) {

    sharedQueue.notifyAll();

    return (Integer) sharedQueue.remove(0);

    }

    }

  • dining philosophers problem

    http://en.wikipedia.org/wiki/Dining_philosophers_problem


Top Related