İş Parçacığı (Thread) Bir çok resmin olduğu bir web sitesini düşünelim Örnek: www.cnn.com sitesinin altındaki birkaç resim. "http://i.cdn.turner.com/cnn/.element/img/3.0/global/header/hdr-main.gif" "http://i2.cdn.turner.com/cnn/2011/HEALTH/03/28/pediatrics.social.media.guidelines/tzvids.teen.computer.thinkstock.jpg" "http://money.cnn.com/data/markets/dow.jpg " İşlemci bir çok prosesi çalıştırıyor olabilir.. Ancak, bu prosesin çalıştırılmasına bakarsak, sunucudan ilk resim geldikten sonra ikinci resim istenecek, ikinci resim geldikten sonra, üçüncü resim istenecek… Internet den resmin gelmesini bekle Internet den resmin gelmesini bekle Internet den resmin gelmesini bekle

Proses=Bir iş parçacığı (single thread) Üç resim üç ayrı proses gibi istenebilse 100 İşlemci Zamanlayıcısı 5000 Internet den resmin gelmesini bekle www.cnn.com Birinci resim İkinci resim Internet den resmin gelmesini bekle Üçüncü resim Internet den resmin gelmesini bekle 12000 Proses C Sayfanın ekranda gösterilmesi çok daha hızlı olur

İş parçacığı (thread) Bazı uygulamalarda bir prosesin içinde farklı bölümleri belli sınırlar içinde birbirinden bağımsız çalıştırılabilir. Bir proses içinde birden fazla proses parçacığı paralel olarak çalıştırılabilir. Böyle proses parçacıklarına iş parçacığı (thread) denir. İş parçacığı kavramının yararı bir proses içinde çoklu çalıştırma imkanının sunulmasıdır. Tek bir proses içinde çoklu iş parçacıklarının çalıştırılabilmesi, çoklu programlamada birden fazla prosesin çalıştırılabilmesine denktir.

İş Parçacığı Modeli

Üretici Tüketici Problemi Üretici tüketici tarafından tüketilen bilgileri üretir (yazıcı programı ve yazıcı sürücüsü), (derleyici ve çevirici), (çevirici ve yükleyici) out (ilk dolu pozisyon) Producer //(Üretici) while (true) { while (((in+1) mod buf_size) = out); // do nothing buffer[in] = next_produced; in = (in+1) mod buf_size; } 1 2 3 Consumer //(Tüketici) while (true) { while (in = out); // do nothing next_consumed = buffer[out] out = (out+1) mod buf_size; } 7 4 6 5 in (bir sonraki boş tampon bellek) Tampon bellekte en fazla kaç tane birim olabilir?

Üretici Tüketici Problemi Int buf_size = 8, counter in, out Array buffer[0..buf_size-1] Başlangıç değerleri counter = 0 in = 0 out = 0 Producer While (counter = buf_size); // do nothing counter = counter + 1 buffer[in] = next_produced; in = (in+1) mod buf_size; Consumer While (counter = 0); // do nothing counter = counter - 1 next_consumed = buffer[out] out = (out+1) mod buf_size; out 1 2 3 7 4 İki proses aynı zamanda çalıştırılırsa bu çözümdeki problem nedir? 6 5 in

producer ve consumer proseslerinin aynı anda çalıştırıldığını düşünün Problem producer ve consumer proseslerinin aynı anda çalıştırıldığını düşünün register1 = counter register2 = counter register1 = register1 + 1 register2 = register2 - 1 counter = register1 counter = register2 T0: producer register1 = counter (register1 = 5) T1: producer register1 = register1 + 1 (register1 = 6) T2: consumer register2 = counter (register2 = 5) T3: consumer register2 = register2 - 1 (register2 = 4) T4: producer counter = register1 (counter = 6) T5: consumer counter = register2 (counter = 4)

Kritik Bölüm Bir prosesin ortak parametreleri değiştirdiği, bir tabloyu güncelleştirdiği, bir dosyaya yazdığı bölüm Bir proses bir kritik bölümünde ise, başka hiçbir prosesin kendi kritik bölümüne girmesine izin verilmemeli Buna kritik bölümlerin karşılıklı dışlanarak çalıştırılması diyoruz (MUTUALLY EXCLUSIVE=karşılıklı dışlama)

Karşılıklı Dışlama İçin Gereksinimler Bir kaynak için sadece bir proses kritik bölümünde olabilir Bir başka proses kritik bölümünde değilse, diğer bir prosesin kritik bölümüne girişi engellenmemeli Proseslerin hızı veya bir kaynağı kaç prosesin kullandığı konusunda hiçbir varsayım yapılmamalı Bir proses kritik bölümünden belli bir süre sonunda çıkmalı

Proseslerin İlişkileri Prosesler birbirinin ne yaptıklarını bilemezler ve ortak kaynaklar için birbirleriyle yarışırlar (not designed to work together; competing) Prosesler birbirlerinden dolaylı olarak haberdardırlar (Share access to an object; cooperating) Prosesler doğrudan birbirlerinden haberdar olabilirler (designed to work together and communicate with each other)

Yemek Yiyen Filozoflar Problemi Sadece düşünen ve yemek yiyen 5 filozof yuvarlak bir masa etrafına oturmuşlar Masanın ortasında bir tencere makarna var Masada 5 çatal şekilde görüldüğü gibi yerleştirilmiş Bir filozofun yemek yemek için iki çatala ihtiyacı var. Sadece sağındaki veya solundaki çatalı kullanabilir İki çatala sahip olan pilavdan doyuncaya kadar yer. Bitirdiği zaman her iki çatalıda masaya bırakır.

Yemek Yiyen Filozoflar Problemi Kilitlenme ve açlık problemlerini çalışmak üzere tanımlanmış klasik problem. 5 filozofun hepsi aynı anda yemek yemek isterse ne olur 2 filozof hep yemek yerse ne olur

Üretici Tüketici Problemi Int buf_size = 5, count in, out Array buffer[0..buf_size-1] Initially count = 0 in = 0 out = 0 Producer While (count = buf_size) ; // do nothing count = count + 1 buffer[in] = next_produced; in = (in+1) mod buf_size; Consumer While (count = 0); // do nothing count = count - 1 consumed = buffer[in]; out = (out-1) mod buf_size; İki proses aynı anda çalışırsa, bu çozümde bir problem var.. Nedir?

Problem Üretici ve tüketici proseslerinin aşağıdaki gibi aynı anda çalıştığını varsayın register1 = counter register2 = counter register1 = register1 + 1 register2 = register2 - 1 counter = register1 counter = register2 T0: producer execute register1 = counter (register1 = 5) T1: producer execute register1 = register1 + 1 (register1 = 6) T2: consumer execute register2 = counter (register2 = 5) T3: consumer execute register2 = register2 - 1 (register2 = 4) T4: producer execute counter = register1 (counter = 6) T5: consumer execute counter = register2 (counter = 4)

İlk Deneme Sadece bir prosesin kritik bölümde olabileceğini garantiler initialize turn=0 do { while (turn is not equal to 0) ; critical section turn = 1; remainder section } while(1); do { while (turn is not equal to 1) ; critical section turn = 0; remainder section } while(1); Sadece bir prosesin kritik bölümde olabileceğini garantiler Ancak prosesler kritik bölüme sırayla girebilir (producer, consumer, producer, consumer, gibi). Yani producer kritik bölüme iki kez üst üste giremez. Sadece hangi prosesin kritik bölüme girebileceğini hatırlar

initialize turn=0 do { While (count = buf_size) ; // do nothing while (turn is not equal to 0) ; count = count + 1 turn = 1; buffer[in] = next_produced; in = (in+1) mod buf_size; } while(1); do { While (count = 0); // do nothing while (turn is not equal to 1) ; count = count - 1 turn = 0; consumed = buffer[in]; out = (out-1) mod buf_size; } while(1);

İkinci Deneme Yanlış Çözüm !!! Her bir proses diğer prosesin statüsünü boolean dizi flag[]’ı kullanarak kontrol eder ancak değiştiremez Bir proses kritik bölüme girmek istediğinde diğer prosesin kritik bölümde olup olmadığını kontrol eder Eğer kritik bölmede başka proses yoksa kritik bölüme girer Kritik bölmeden çıktığında kendi flag[] değerini değiştirerek diğer proseslerin kritik bölmeye girmelerine izin verir initialize flag[0] and flag[1] to false; do { flag[0] = true; while (flag[1] ) ; critical section flag[0] = false; remainder section } while(1); do { flag[1] = true; while (flag[0] ) ; critical section flag[1] = false; remainder section } while(1); P0 P1 Yanlış Çözüm !!!

Üçüncü Deneme Yanlış Çözüm !!! initialize flag[0] and flag[1] to false; do { while (flag[1]) ; flag[0] = true; critical section flag[0] = false; remainder section } while(1); do { while (flag[0] ) ; flag[1] = true; critical section flag[1] = false; remainder section } while(1); P0 P1 Yanlış Çözüm !!!

Dördüncü Deneme Petterson un Algoritması initialize flag[0] and flag[1] to false; initialize turn = 0 do { flag[0] = true; turn=1 while (flag[1] and turn = 1) ; critical section flag[0] = false; remainder section } while(1); do { flag[1] = true; turn=0 while (flag[0] and turn = 0) ; critical section flag[1] = false; remainder section } while(1); P0 P1

Bakery’nin karşılıklı dışlama algoritması Prosesler bir numara alıyor. En küçük numaraya sahip proses kritik bölüme girer. 1 var choosing: shared array[0..n-1] of boolean; 2 number: shared array[0..n-1] of integer; ... 3 repeat 4 choosing[i] := true; 5 number[i] := max(number[0],number[1],...,number[n-1]) + 1; 6 choosing[i] := false; 7 for j := 0 to n-1 do begin 8 while choosing[j] do (* nothing *); 9 while number[j] <> 0 and (number[j], j) < (number[i],i) do 10 (* nothing *); 11 end; 12 (* critical section *) 13 number[i] := 0; 14 (* remainder section *) 15 until false; "(a,b) < (c,d)" anlamı if a < c or if a = c and b < d

Nasıl Çalışıyor 1-2 satırlar: Eğer Pi sayısını bulmaya çalışıyorsa choosing[i] değeri true. number[i] kritik bölgeye kaçıncı sırada gireceğini belirler. Eğer 0 ise, kritik bölüme girmek istemiyor demektir. 4-6 satırlar: Proses kendine özel bir sıra numarası almaya çalışıyor. Ancak bu rakkam her zaman benzeri olmayan bir rakam olmayabilir. Satır 6 da sıra numarası alma işleminin bittiğini belirtiyor. 7-12 satırlar: Burada hangi prosesin kritik bölüme gireceğini seçiyoruz. Pi tüm bekleyen prosesler içinde en küçük numaraya sahip oluncaya kadar bekler. Eğer iki proses aynı numaraya sahipse o zaman adı daha küçük olan kritik bölmeye girer. "(a,b) < (c,d)" anlamı if a < c or if a = c and b < d (satır 9-10). Eğer bir proses kritik bölüme girmeye çalışmıyorsa numarası 0 dır. Eğer bir proses numara almaya çalışıyorsa ve başka bir proses onun statüsünü kontrol ediyorsa, numara alma işlemi bitinceye kadar bekler (satır 8). line 13: Pi kritik bölme ile işi kalmadığı için number[i]=0.

Bakery’nin karşılıklı dışlama algoritması Çalıştığını Gösterin 1 var choosing: shared array[0..1] of boolean; 2 number: shared array[0..1] of integer; ... 3 repeat 4 choosing[i] := true; 5 number[i] := max(number[0],number[1]) + 1; 6 choosing[i] := false; 7 for j := 0 to 1 do begin 8 while choosing[j] do (* nothing *) ; 9 while number[j] <> 0 and (number[j], j) < (number[i],i) do (* nothing *); 10 end; 11 (* critical section *) 12 number[i] := 0; 13 (* remainder section *) 14 until false; "(a,b) < (c,d)" anlamı if a < c or if a = c and b < d

Bakery’nin karşılıklı dışlama algoritması Çalışmadığını Gösterin 1 var choosing: shared array[0..1] of boolean; 2 number: shared array[0..1] of integer; ... 3 repeat 4 (* choosing[i] := true; *) 5 number[i] := max(number[0],number[1]) + 1; 6 (* choosing[i] := false; *) 7 for j := 0 to 1 do begin 8 (* while choosing[j] do (* nothing *) *); 9 while number[j] <> 0 and (number[j], j) < (number[i],i) do (* nothing *); 10 end; 11 (* critical section *) 12 number[i] := 0; 13 (* remainder section *) 14 until false; "(a,b) < (c,d)" anlamı if a < c or if a = c and b < d

Niye Çalışmıyor İki proses P0 ve P1 5. satıra aynı anda ulaşıyor. Aynı anda number[0] ve number[1] i hiçbir toplama işlemi olmadan önce okuyorlar. P1 5. satırı tamamlıyor (number[1]=1) P0 çalışmıyor. P1 kritik bölüme giriyor ve işlemci P1 den P0 a geçiyor. P0 number[0]=1 yapıyor ve while loopuna giriyor. j=1 için ilk test doğru ancak ikinci test yanlış. Bu durumda P0 da kritik bölüme giriyor ve karşılıklı dışlama şartı yerine getirilmemiş oluyor. choosing i kullanmamızın sebebi eğer bir proses rakamını seçiyorsa bir başka prosesin 9uncu satırdaki while loopuna girmesini engellemektir. Eğer bir proses loopa girerse ve diğer bir proses 5. satıra ulaşırsa: Loop daki ilk testde number[j]=0 olabilir ki bu durumda proses i bir sonraki prosese geçer, veya, number[j] 0 dan büyüktür. Bu durumda number[j] bir süre içinde number[i] dan büyük olacaktır (çünkü Pi Pj den önce 5. satırı çalıştırdığı için). Her iki durumda Pi Pj den önce kritik bölüme girecektir ve Pj Pi kritik bölümden çıkıncaya kadar while loopunda bekliyecektir.

Karşılıklı Dışlama: Donanım Desteği Bir işlemcili sistem Bir proses bir işletim sistem servisi çağırıncaya veya işletim sistemi tarafından durduruluncaya kadar çalışmaya devam eder İş kesme işlemini devre dışı bırakırsak karşılıklı dışlama sağlanır Ancak bu durumda işlemci birden fazla prosese verilemez Birden fazla işlemcili sistem İş kesme işlemini devre dışı bırakırmak karşılıklı dışlamayı garanti edemez

Karşılıklı Dışlama: Donanım Desteği Özel işlemci komutları Tek bir komut döngüsünde çalıştırılır Diğer komutlardan bağımsız çalışır Test and Set Instruction (Atomic) boolean testset (boolean &target) { boolean rv = target; target = true; return rv; } lock=false; do while (TestAndSet(lock)); critical section lock = false; remainder section } while (1);

Karşılıklı Dışlama: Donanım Desteği lock=false; do key = true; while (key=true) Swap(lock,key); critical section lock = false; remainder section } while (1); Swap Instruction void Swap(boolean &a, boolean &b) { boolean temp=a; a=b; b = temp; }

Karşılıklı Dışlama: Donanım Desteği Faydaları Tek bir işlemci veya birden fazla işlemcili sistemlerde birden fazla prosesçe aynı anda kullanılabilir Kullanılması ve doğrulaması kolaydır Birden fazla kritik bölge için değişik değişkenler kullanılarak çözüm üretilir Dezavantajları Meşgul bekleme işlemci zamanının boşa kullanılmasıdır Birden fazla proses kritik bölmeye girmeye çalışıyorsa açlık sorunu olabilir Kilitlenme Eğer önceliği az olan bir proses kritik alanda ise ve önceliği daha yüksek olan ve kritik alana girmek isteyen bir proses tarafından durdurulursa, kilitlenme olur

Semafor Prosesler arasında işaretleşmek için semafor denilen özel değişkenler kullanılır İki atomic işlem: WAIT and SIGNAL Wait and signal işlemleri durdurulamaz Wait işlemi semaforun değerini bir azaltır. Eğer negatif olursa proses durdurulur (ta ki sıfır veya pozitif oluncaya kadar) Signal işlemi semafor değerini bir arttırır Semaforu bekleyen prosesler o semaforun kuyruğunda bekler Wait(S) { while S less than or equal to 0 ; S = S-1; } Signal(S) { S = S+1; } P1 prosesi S1 komutunu ve P2 prosesi S2 komutunu çalıştıracak. S2 komutunun S1 komutundan sonra çalışmasını garantileyecek bir çözüm bulun. Semafor synch un ilk değeri 0 olarak tanımlanır. S1; WAIT(synch); SIGNAL(synch); S2;

Semafor Bir semafor un tam sayı bir değeri ve bir proses listesi vardır. Bir proses bir semaforu bekleyecekse (WAIT) proses bloklanır ve semaforun listesine eklenir. SIGNAL işlemi listeden bir prosesi çıkarır ve onu uyandırır. Typedef struct { int value; struct process *L; } semaphore; WAIT(semaphore S) { Decrease the value of S by 1; If (S.value less than 0) { add this process to S.L; block(); } SIGNAL(semaphore S) { Increase the value of S by 1; If (S.value less than or equal to 0) { remove a process from S.L; wakeup(P); }

Dining Philosophers Problem Sadece düşünen ve yemek yiyen 5 filozof yuvarlak bir masa etrafına oturmuşlar Masanın ortasında bir tencere makarna var Masada 5 çatal şekilde görüldüğü gibi yerleştirilmiş Bir filozofun yemek yemek için iki çatala ihtiyacı var. Sadece sağındaki veya solundaki çatalı kullanabilir İki çatala sahip olan pilavdan doyuncaya kadar yer. Bitirdiği zaman her iki çatalıda masaya bırakır.

Philosopher i Her bir çatalı bir semaforla temsil edelim Çatalı almak için WAIT işlemini çalıştıralım Çatalı bırakırken SIGNAL işlemini çalıştıralım Bütün çatalların ilk değeri 1 olsun do{ WAIT(çatal[i]); WAIT(çatal[i+1]); eat SIGNAL(çatal[i]); SIGNAL(çatal[i+1]); think } while (1); Karşılıklı dışlanma garanti edildi ama kilitlenme olasılığı var Masaya sadece dört filozofu oturttur Bir filozofun bir çatalı alması için diğer çatalında kullanılmıyor olduğunu kontrol et ve sadece iki çatalı birden almasına izin ver Tek sayılı filozof önce sol sonra sağ çatalını alsın. Çift sayılı filozof önce sağ sonra sol çatalı alsın.

Filozof0 Tek sayılı filozof önce sol sonra sağ çatalını alsın. Çift sayılı filozof önce sağ sonra sol çatalı alsın. do{ WAIT(çatal[1]); WAIT(çatal[0]); eat SIGNAL(çatal[0]); SIGNAL(çatal[1]); think } while (1); 4 4 Filozof1 3 do{ WAIT(çatal[1]); WAIT(çatal[2]); eat SIGNAL(çatal[2]); SIGNAL(çatal[1]); think } while (1); 3 1 1 2 2

Kilitlenme İki veya daha prosesin sürekli sürekli olarak bir veya daha fazla sistem kaynaklarını bekleme durumu Etkin bir çözümü yok İki veya daha fazla prosesin birbiriyle çakışan kaynak ihtiyaçlarından ortaya çıkan bir problem

Kilitlenmenin Sebepleri Kilitlenme olabilmesi için aşağıdaki dört koşulun aynı anda gerçekleşmesi gerekir Karşılıklı dışlama: bir kaynağı sadece bir proses kullanabilir Tut ve Bekle: bir kaynağı tutan bir proses kritik bölümden çıkabilmek için başka bir proses tarafından tutulan bir kaynağı bekliyor. Çağrı üstünlüğüyle sökememe (no preemption): bir kaynak onu kullanan proses tarafından sadece gönüllü olarak serbest bırakılabilir Döngüsel bekleme: {P0, P1, …, Pn} bekleyen prosesler seti olsun. P0 , P1 tarafından tutulan bir kaynağı bekliyor, P1 , P2 tarafından beklenen bir kaynağı tutuyor,…, Pn–1 , Pn tarafından tutulan bir kaynağı bekliyor, ve Pn , P0 tarafından tutulan bir kaynağı bekliyor.

Kilitlenmeye Örnek

Örnek Proses A Proses B İste(D) 1 İste(T) Lock(D) 2 Lock(T) İste(T) 3 İste(D) Lock(T) 4 Lock(D) İşlem 5 İşlem Unlock(D) 6 Unlock(T) Unlock(T) 7 Unlock(D)

Kilitlenmenin başka bir örneği Bellekte 200K bytes bir alan kullanılabilir Prosesler ikinci istekleriyle kilitlenmeye sebep olur P1 P2 . . . . . . Request 80K bytes; Request 70K bytes; . . . . . . Request 60K bytes; Request 80K bytes;

Kilitlenmenin Koşulları Karşılıklı dışlama Bir kaynağı belli bir zamanda sadece bir proses kullanabilir. Tut ve bekle Bir proses bir kaynağın kendine verilmesini beklerken kendisine daha önce verilen başka bir kaynağı tutmaya devam eder. Hiçbir kaynak bir prosesden zorla alınamaz.

Kilitlenmenin Koşulları Dairesel bekleme Bir zincir prosesde her bir prosesin ihtiyacı olan bir kaynak zincirdeki bir sonraki proses tarafından tutuluyor olması.

Tüm Koşullara Bakıldığında İlk üç koşul dördüncü koşula sebebiyet verir Dört koşulun hepsi kilitlenme için gerekli ve yeterlidir Sistem tasarımının kilitlenme olasılığına izin verilmeyecek şekilde yapılması gerekir.

Kilitlenmeyi Önleme Indirect method calls for preventing the occurrence of first 3 conditions Direct method calls for preventing the fourth condition Mutual Exclusion is unavoidable Hold and wait can be eliminated by forcing the processes to request all resources at the same time (impractical) If a process is denied a requested resource, it should release the resource currently held Define linear ordering of resource types so a process can only request next resource in the linear order.

Kilitlenmeden Kaçınma Prevention results in inefficient use of resources We can use deadlock avoidance in which first three conditions still hold A decision is made dynamically whether the current resource allocation request will, if granted, potentially lead to a deadlock Requires knowledge of future process request

Kilitlenmeden Kaçınmak için İki Koşul Eğer bir sürecin kaynak ihtiyaçları kilitlenmeye yol açacaksa o süreci başlatma Bir sürecin çalışırken ki bir kaynak isteği kilitlenmeye yol açacaksa o kaynağı sürece verme

Süreci Başlatma Reddi Süreç tüm kaynak ihtiyaçlarını başlamadan önce belirtir Bir süreç sadece tüm kaynak ihtiyaçları daha önceden başlatılmış süreçlerin kaynak ihtiyaçlarına ek olarak karşılanabilecekse başlatılır En kötü durum stratejisidir çünkü because tüm kaynaklar ne zaman kullanılacaklarından bağımsız olarak baştan istenir

Kaynak Tahsisi Reddi Banker’in algoritması olarak bilinir Sistemin konumu o andaki süreçler arası kaynak paylaşımıdır Güvenilir konum tüm süreçlerin kilitlenme olmadan tamamlanabildikleri bir konumdur Güvenilir olmayan konum kilitlenmeye yol açan konumdur

Güvenilir Konum Eğer sistem kaynakları her bir sürece herhangi bir sırada verebilir ve tüm süreçler tamamlanabilirse o zaman sistem güvenilir bir konumda denir Süreç Max İhtiyaç Şu anda elinde P0 10 5 P1 4 2 P2 9 2 12 kaynak olduğunu varsayalım (P1, P0, P2) güvenilir bir konumda Sistem güvenilir bir konumdan güvenilir olmayan bir konuma gidebilir Örneğin P2 nin bir kaynak istediğini ve ona bu kaynağın verildiğini varsayın

Başlangıç Konumu P2 süreci tamamlanır

P1 süreci tamamlanır P3 süreci tamamlanır

Güvenilir Olmayan Konum Tayini Başlangıç P1 birer tane R2 ve R3 ister; Bu sistemi güvenilir olmayan bir konuma getirir

Başka Bir Örnek Process Max İhtiyaç Şu andaki durum Mevcut A B C A B C A B C P0 7 5 3 0 1 0 3 3 2 P1 3 2 2 2 0 0 P2 9 0 2 3 0 2 P3 2 2 2 2 1 1 P4 4 3 3 0 0 2 Güvenilir konumda (P1, P3, P4, P2, P0) sırasıyla tüm süreçler tamamlanabilir P1 (1,0,2) istediğini ve bu kaynakların P1 e verildiğini varsayın Process Max İhtiyaç Şu andaki durum Mevcut A B C A B C A B C P0 7 5 3 0 1 0 2 3 0 P1 3 2 2 3 0 2 P2 9 0 2 3 0 2 P3 2 2 2 2 1 1 P4 4 3 3 0 0 2 (P1, P3, P4, P0, P2)

Kilitlenmeden Kaçınma Koşulları Tüm süreçlerin her bir kaynak ihtiyacı baştan bilinmeli Süreçler birbirlerinden bağımsız çalışmalı, hiçbir eşitleme (synchronization) gereksinmeleri olmamalı Kaynak sayıları sabit olmalı, önceden bilinmeli Hiçbir proses kaynakları tutarken bitirilmemeli