1.Utilitatea concurenței. Avantaje și dezavantaje  Avantaje:  1)Creșterea vitezii de excuție;  

a.Un fir pentru GUI;  b.Acc

es paralel la BD și pagini Web;  

2)Programarea reactivă:  a)Utilizatorul poate interacţiona cu aplicaţii în timp ce sarcini

se execută, de exemplu, oprirea transferul unui fişier mare într-un browser web;  b)Disponibilitatea de servicii  - Sarcini de lunga durata nu trebuie să întârzie cu cele de scurtă durată, de exemplu, un server de web poate servi o pagină,care în acelaşi timp, este procesată o interogare complexă  • Paralelism  - Programe complexe pot face o mai bună utilizare a resurselor multiple în noi arhitecturile multi-core procesor, PMM, LAN sau WAN-urile, de exemplu, ştiinţifice / aplicaţii de inginerie, simulari, jocuri, etc  • Controlabilitate  - Sarcini care necesită anumite condiţii prealabile poate suspenda şi aşteptaţi până când deţin precondiţii, apoi relua executarea transparent.  2)Protecție-izolarea unor algoritmi în fire aparte. Dezavantaje:  1)Siguranţă  

- «Nimic nu se întâmplă niciodată rău»  - Sarcini concurente nu ar trebui să nu corupt coerentă a programului  • vivacitatea  - «Orice vreodată se întâmplă la toate»  - Sarcini nu ar trebui să suspende pe termen nelimitat şi aşteptaţi pentru fiecare alte (impas).  • non-determinism  - Mastering numărul exponenţială a interleavings datorită programe diferite.  • Consumul de resurse  - Fire poate fi costisitoare. Suspendate de programare, context-comutare, şi sincronizare.  - Programe concurente poate rula mai lent decât omologii lor secvenţială  chiar cu mai multe procesoare!  

   2)Calcul distribuit, paralel și concurent: relații și caracteristici  a)Sistem de calcul paralel:  Procesoarele de obicei sunt de același tip;  Scopul:Executarea unor calcule mai rapid decât cu un singur procesor. b)Sistem de calcul distribuit:  a)Procesoarele sunt de obicei eterogene;  Sistemele distribuite au apărut ca o necesitate pentru:  - schimbul de informaţii între noduri;  - partajarea unor resurse (printere, memorie backup, unităţi de disc etc.);  - siguranţa în funcţionare: dacă un nod \"cade\", întregul sistem trebuie (dacă este posibil) să fie capabil să asigure în continuare funcţionarea, prin redirijarea (rutarea) mesajelor prin nodurile funcţionale.  

c)Sistem de calcul concurent:  Coordonarea activității multi-tasks, multithread.  

   3.Programarea obiect-orientată și efectele nefaste ale concurenței (deadlock, livelock, starvation, race condition) Deadlock-o situaţie în care două sau mai multe acţiuni concurente sunt, fiecare în aşteptare , ca una sau cealalata acțiune să se termine, şi, astfel, nici nu se va finisa vreodată.  Livelock - cu excepţia faptului că stările din proceselor implicate în livelock constant schimba cu  privire la una alta, nici una progresează.  Race Condition - as condiţie apare atunci când mai multe fire a unei applicaței multithread încercă să obţină acces simultan la date.Și nu se cunoaște care fir se va executa(Nedeterminist).  

   4)Recomandări generale pentru programe concurentă:  a)Trebuie să fie cunoscut protocolul de interacțiune,pentru evitarea deadlock;  b)De minimizat interacțiunile concurente.  

   6)Limbajul Java: crearea firelor de execuție (clasa Thread și interfața Runnable)  getName → Obtain a thread’s name. getPriorit

y → Obtain a thread’s priority.  isAlive → Determine if a thread is still running. Join → Wait for a thread to terminate.  run → Entry point for the thread.  Sleep → Suspend a thread for a period of time. Start → Start a thread by calling its run method.  public class csj01x2 implements Runnable  {  

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

csj01x2 obj1 = ne

w csj01x2(); csj01x2 obj2 = new csj01x2(); new Thread(obj1).start();  new Thr

ead(obj2).start();  // main thread is ending here,  // Thread-0 and Thread-1 continue to run.  

}    

public void run()  {  

try {  for

(i

nt i=0; i<100; i++) { System.out.println("thr

ead "  

+Thread.currentThread().getName()+" step "+i); Thread.sleep(500);  

}  } catch (Throwable t) { }  

}  }output:  

 thread Thread-0 step 0 thread Thread-1 step 0 thread Thread-0 step 1 thread Thread-1 step 1 thread Thread-0 step 2 thread Thread-1 step 2  

....  

 

 7)LimbajulC#:creareafirelordeexecuție(Thread,Invocăriasincrone,ThreadPool) . C # sprijină execuţia în paralel a codului prin multithreading.Un fir este o cale de executare independent, capabil de a rula simultan cu alte fire.  class  ThreadTest  {  static  void  Main()  {  Thread  t  =  new  Thread  (WriteY);  //  Kick  off  a  new  thread  t.Start();                                      //  running  WriteY()  

   //  Simultaneously,  do  something  on  the  main  thread.  for  (int  i  =  0;  i  <  1000;  i++)  Console.Write  ("x");  }  

   static  void  WriteY()  {  for  (int  i  =  0;  i  <  1000;  i++)  Console.Write  ("y");  }  

}          b)asyncronis static  void  Main()  {  Func<string,  int>  method  =  Work;  IAsyncResult  cookie  =  method.BeginInvoke  ("test",  

null,  null);  //  

//  ...  here's  where  we  can  do  other  work  in  parallel...  //  int  result  =  method.EndInvoke  (cookie);  Console.WriteLine  ("String  length  is:  "  +  result);  

}      static  int  Work  (string  s)  {  return  s.Length;  }  

                   c)threadPool  static  void  Main()  {  ThreadPool.QueueUserWorkItem  (Go);  ThreadPool.QueueUserWorkItem  (Go,  123);  Console.ReadLine();  

}      static  void  Go  (object  data)  //  data  will  be  null  with  the  first  call.  {  Console.WriteLine  ("Hello  from  the  thread  pool!  "  +  data);  

}    8.Structuri primitive de sincronizare și stările unui fir de execuție(Limbajul Java/C#)  

 

// This program uses a synchronized block. class Callme {  void call(String msg) { Syste

m.out.print("[" + msg); try {  

     Thread.sleep(1000);  } catch

(InterruptedException e) { System.out.println("Interrupted");  } System.out.println("]");  }  }  class Caller implements Runnable { String msg;  Callme target; Thread t;  public Caller(Callme targ, String s) {  target = targ;  msg = s;  t = new Thread(this);  t.start();  }  // synchronize calls to call()  public void run() {  synchronized(target) { // synchronized block

target.call(msg);  }  }  }  class Synch1 {  public static void main(String args[]) { Callme target = new Callme();  Caller ob1 = new Caller(target, "Hello");  Caller ob2 = new Caller(target, "Synchronized"); Caller ob3 = new Caller(target, "World");  // wait for threads to end try {  ob1.t.join(); ob2.t.join(); ob3.t.join();  } catch(InterruptedException e) {  

 System.out.println("Interrupted");  }  }  }  

9.Calculul paralel ca și strategie de a rezolva mai rapid probleme de complexitate ridicată.  -Modelarea schimbării climei și prognozarea vremii;  -Inginerie genetică;  -Sinteza noilor materiale;  -Simulări aeronautice;  

-Simulare structuri/construcții automobile;  -Modelare economico-financiară;  -Oprimizarea extragerii petrolului și gazului.  

   10.Calcul paralel: definiții și criteriile arhitecturale(partajarea resurselor, accesul la date, comunicarea, sincronizarea)  Almasi și Gotlieb → CP- o colecție de elemente de procesare ce comunică și cooperează pentru  a rezolva mult mai rapid probleme de procesare de dimesiuni mari.  Foster → un set de procesare capabile sa coopereze pentru rezolvarea unor probleme de calcul.  Soluții dependente de arhitecturi →  -Partajarea resurselor;  -Accesul la date;  -Comunicarea;  -Sincronizarea.  

   11.Factori negativi în dezvoltarea și utilizarea calculatoarelor paralele.  a)Prețul înalt al sistemelor paralele.  Legea lui Grosh → productivitatea calculatorului crește proporțional prețului la pătrat;  b)Pierderi de productivitate legate de organizarea paralelismului;  Legea lui Minsky → Accelerarea atinsă la utilizarea sistemelor paralele este proporțională lagaritmului în baza doi de numărul de procesoare;  c)Perfecționarea continuă a calculatoarelor secvențiale;  Legea lui Moore → Productivitatea calculatoarelor paralele crește de două ori în fiecare 18 luni. d)Dependența eficienței paralelismului de caracteristicile arhitecturale și funcționale ale sistemelor paralele;  e)Aplicațiile existente sunt orientate în special spre mașini secvențiale.  

   12.Forme și nivele de implementare a paralelismului  

     

   

   13.Modele de programare și concurența  

       14.Problema excluderii reciproce în programarea concurentă  

 

 

 

 15.Încercările Dijkstra pentru rezolvarea problemei de excludere reciprocă  1)Incercare 1 lui Dijkstra  

     

       2)Incercare 2 lui Dijkstra  

                         

       3)Incercare 3 lui Dijkstra  

 4)Incercare 4 lui Dijkstra  

     16.Algoritmul Dekker pentru rezolvarea problemei de excludere reciprocă  

     17.Algoritmul Peterson pentru rezolvarea problemei de excludere reciprocă  

       18.Semaforul Dijkstra și rezolvarea problemei de excludere reciprocă  

     19.Clase Semaphore în limbaje de programare (Limbajul Java/C#)  

  java.util.concurrent.Semaphore  

 

A counting semaphore. The methods acquire() and release() are used here instead of P() and V(). Each acquire() blocks if necessary until a permit is available, and then takes it. Each release() adds a permit, potentially releasing a blocking acquirer. [1]  

 import java.util.concurrent.Semaphore;  import java.util.Random;    //Solving the mutual exclusion problem using Semaphore class    class Process2 extends Thread  {  

private static final Random rand = new Random();    

private int id;    

private Semaphore sem;    

public Process2(int i, Semaphore s)  {  

id = i;  sem = s;  

}    

private void busy()  {  

try  {  

   sleep(rand.nextInt(500));  

} catch (InterruptedException e)  {  }  

}    

 

private void noncritical()  {  

System.out.println("Thread " + id + " is NON critical");  busy();  

}    

private void critical()  {  

System.out.println("Thread " + id + " entering critical section");  busy();  System.out.println("Thread " + id + " leaving critical section");  

}    

public void run()  {  

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

noncritical();  try  {  

sem.acquire();  } catch (InterruptedException e)  {  

// ...  }  critical();  sem.release();  

}  }  

 public static void main(String[] args)  {  

final int N = 4;    

System.out.println("Busy waiting...");    

//Semaphore(int permits, boolean fair) Semaphore sem = new Semaphore(N, true);  

 Process2[] p = new Process2[N];  

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

p[i] = new Process2(i, sem);  p[i].start();  

}  }  

}      20.Tehnici de sincronizarea a activităților concurente: signaling, rendez-vous, mutex, multiplex, bariera.  

1) Semnalizare- este procedeul cind dorim sa asiguram o executie a unei secvente de  instructiuni din diferite fire concurente  

2) Rendez-vous- est eprocedeul cind dorim sa ne asiguram ca la un moment dat de executtie un fir sa astepte alt fir si invers  

           

       

3) Mutex- este procedeul cind dorim sa asigurame excluderea reciproca  

             

   

   4) Multiplex- este procedeul utilizxat cind avem mai multe fire de executie m si dorim sa permitema cccesul la un numar n de fire n<m  

5) Bariera 1- este problema care solutioneaza redez-vous generalizata(num de fire>2)  

                             

6) Bariera2 - este problema care solutioneaza redez-vous generalizata(num de fire>2 si toate firele pleaca dupa ce ultimul isi va executa operatia lui critica )  

 

                               21.Problema de programare concurentă Jocul Vieții  

   

     22.Problema de programare concurentă Producător-consumator  Producătorul produce articole care sunt așezate pe o bandă.Consumatorul ia de ăe bandă articolele și le consumă.  

   23.Problema de programare concurentă Filosofii chinezi  La o masă rotundă stau 5 filozofi chinezi.Principala lor activitate este cea de gândi, dar evident din când în când trebuie să mănânce,folosind pentru aceasta 2 bețișoare.Știind că înte oricare 2 filozofi se află un bețișor și că un filozof poate mînca doar dacă a ridicat de pe masă atât bețișorul din stînga sa,cât și bețișorul din dreapta, se cere să se simuleze activitățile filozofilor așezați la masă.  

     

                                       24.Problema de programare concurentă Cititori-scriitori  

                 26.Problema de programare concurentă Bărbierul somnoros  

 

                                                                                     

                                                 25.Problema de programare concurentă Bărbierul somnoros  

   27.Problema de programare concurentă Sushi bar