Klasszikus IPC problémak (processzus kommunikació)

Klasszikus IPC problémák (processzus kommunikáció)

Étkező filozófusok problémája

Öt filozófus ül egy kerek asztal körül és van egy tányér spagettijük, ám a spagetti olyan cs 545e43f úszós, hogy két villa kell az étkezéshez.

Egy filozófus élete egymást váltakozó evésből és gondolkodásból áll.

Ha egy filozófus éhes lesz, megpróbálja megszerezni mindkét villát, de egyszerre csak egyet.

#define N 5

Void philosopher (int i)

Mind az öt egyszerre veszi fel a bal villát! (éheztetés)

Éheztetés: Minden program korlátlan ideig fut, de nem tesz semmit a fejlődés érdekében.

#define N 5

#define LEFT (i-1)%N                         //i bal szomszédjának a száma

#define RIGHT (i+1%N)                                  //i jobb szomszédjának a száma

#define THINKING 0                          //a filozófus gondolkodik

#define HUNGRY 1       //a filozófus megpróbál villát szerezni

#define EATING 2         //a filozófus eszik

typedef int semaphore;

int state[N];                    //tömb az állapotok nyomon követésére

semaphore mutex=1;      //a kritikus szekciók kölcsönös kizárása

semaphore s[N];             //filozófusonként egy szemafor

Void philosopher (int i)                         //filozófusszám 0 - (N-1)-ig

Void take_forks (int i)                           //i a filozófus száma

Void test(i)

Egy filozófus csak akkor het, ha egyik szomszédja sem eszik.

Olvasók-írók problémája

A filozófus probléma csak akkor jó, ha a processzusok korlátozott számú erőforrást pl. B/K-t használnak.

Ez a probléma adatbázis elérését modellezi.(pl. légitársaság helyfoglalási rendszere). Az elfogadható, hogy több processzus olvassa az adatbázist, de az nem, hogy több írja egyidejűleg.

Typedef int semaphore;

Semaphore mutex=1;                  //rc elérését vezérli

Semaphore db=1;                       //az adatbázis elérését vezérli

Int rc=0;                                     //az olvasók vagy az akarók száma

Void reader (void)

Void writer (void)

Az első olvasó végrehajt egy DOWN-t a db szemaforon.

A következő olvasók csak az rc számlálót növelik.

Az utolsó kilépő végrehajt egy UP-ot a szemaforon, megengedve a blokkolt írónak ha van ilyen a belépést.

Az író csak abba léphet be, amibe az olvasók száma 0-ra csökken.

Megelőzendő ha jön egy író a többi új olvasó blokkolódik.

Alvó borbély probléma

Fodrászüzletben egy borbély van, egy borbélyszék, és n várakozószék. Ha nincs vendég a borbély alszik. Ha vendég jön, a borbélyt fel kell ébreszteni. Ha a borbély dolgozik és új vendég jön, akkor ha van várakozószék, leülteti, ha nincs elküldi.

Feladat a fenti helyzet versenyhelyzet nélküli programozása.

#define CHAIRS 5                     //öt várakozó szék

typedef int semaphore;

semaphore customers=0;            //kiszolgálásra váró vendégek száma

semaphore barbers=0;    //vendégre váró borbélyok száma 0 vagy 1

semaphore mutex=1;                  //kölcsönös kizárás waitinghez

int waiting=0;                              //hajvágásra váró vendégek száma

Void barber (void)

Void customer (void)

else

Waitingre azért van szükség, mert a szemafor aktuális értékét nem tudjuk kiolvasni, így ebben tároljuk a másolatát.

A borbély kezdésképpen végrehajtja a barber függvényt, és elmegy aludni, míg nem jön egy vendég.

Az Up(customers) felébreszti a borbélyt. Ha customer *** a mutexet, a borbély elkapja azt ***, majd elvégzi a hajvágást. A vendégeknek nincs ismétlés.