Her prosese, merkezi işlem biriminde (cpu'da) işlem görmesi için belli bir süre verilir. Bu süreye quantum süresi denir. Quantum süresi içerisinde proses, merkezi işlem birimini (cpu) kullanır. Bu süre içerisinde işi bitmez ise tekrar sıraya geçer, işi biterse ise o proses sonlanır.

Her bir proses belli bir süre işlem görüp eğer işi bitmemiş ise, tekrar sıraya girer demiştik. İşte bu sebepten dolayı Round-Robin sıralaması kesintili bir sıralamadır. Çünkü bir proses işi bitene kadar işlemciyi (cpu) kullanmıyor. Belli bir süre kullanıp işlemi kesintiye uğruyor, daha sonrasında tekrar işlemciye geliyor ve işi bitene kadar bu döngü devam ediyor.


Round-Robin sıralamasının anlaşılması açısından basit bir örnek yapalım :

P1, P2, P3 adında 3 proses olsun. Bu proseslerden;

P1 prosesinin işini bitirebilmesi için CPU'yu 3 milisaniye kullanması gerektiğini varsayalım.
P2 prosesinin işini bitirebilmesi için CPU'yu 4 milisaniye kullanması gerektiğini varsayalım.
P3 prosesinin işini bitirebilmesi için CPU'yu 2 milisaniye kullanması gerektiğini varsayalım.

Quantum zaman dilimi : 1 milisaniye olsun. Bu değeri ben kendim belirledim.Yani her bir proses işlemcide 1 milisaniye işlem görecek demektir.

Bu konuyu daha iyi anlatabilmem adına, verceğim örnek için işlem görme öncelikleri önemsiz olsun. Önce P1, sonra P2'nin, sonra P3'ün sırada beklediğini düşünelim.

Evet, işlemlerimize başlıyoruz.

1. Adım :
P1 CPU'ya geldi. Quantum 1 olduğu için, 1 milisaniye işlem gördü. Geriye 2 milisaniyesi kaldığı için tekrar sıraya geçer. Daha sonra sırada bekleyen P2 CPU'ya gelir. Quantum 1 olduğu için, 1 milisaniye işlem görür ve 3 milisaniyesi kaldığı için tekrar sıraya geçer. Sonrasında ise P3 CPU'ya gelir. Quantum 1 olduğu için, 1 milisaniye işlem görür ve 1 milisaniyesi daha kaldığı için tekrar sıraya geçer.

İşlerini bitirebilmeleri için kalan işlem görme süreleri :
P1 için 2 milisaniye.
P2 için 3 milisaniye.
P3 için 1 milisaniye.


2. Adım :
Sıra tekrar P1 CPU'ya geldi. 1 milisaniye işlem gördü. Geriye 1 milisaniyesi daha kaldığı için tekrar sıraya geçer. Daha sonra sırada bekleyen P2 CPU'ya gelir. 1 milisaniye işlem görür ve 2 milisaniyesi kaldığı için tekrar sıraya geçer. Sonrasında ise P3 CPU'ya gelir. 1 milisaniye işlem görür ve 0 milisaniyesi kalır. Bu da demek oluyor ki P3 prosesi işini bitirmiştir. Çünkü görmesi gereken 2 milisaniyelik işlemi görmüştür artık.

İşlerini bitirebilmeleri için kalan işlem görme süreleri :
P1 için 1 milisaniye.
P2 için 2 milisaniye.
P3 için 0 milisaniye. İşini bitirmiştir. Sonlanır.


3. Adım
P1 CPU'ya geldi. Quantum 1 olduğu için, 1 milisaniye işlem gördü. Geriye 0 milisaniyesi kaldığı için işi bitmiştir artık ve sonlanır. Daha sonra sırada bekleyen P2 CPU'ya gelir. Quantum 1 olduğu için, 1 milisaniye işlem görür ve 2 milisaniyesi kaldığı için tekrar sıraya geçer. P3 bir önceki adımda sonlanmıştı diye işlem görmez. Bu adımda P1 prosesi de sonlandığı için, bir sonraki adımda P2 prosesi işlem görüp, sonlanacaktır.

İşlerini bitirebilmeleri için kalan işlem görme süreleri :
P1 için 0 milisaniye. İşini bitirmiştir. Sonlanır.
P2 için 1 milisaniye.
P3 bir önceki adımda sonlanmıştı.

4. Adım
P1 CPU'ya geldi. Quantum 1 olduğu için, 1 milisaniye işlem gördü. Geriye 0 milisaniyesi kaldığı için işi bitmiştir artık ve sonlanır.

Tüm prosesler böylece işlerini bitirmiş olurlar.

Quantum 1 milisaniye olduğu için her adımda, her bir prosesin işlem görme süresini 1 azalttık çünkü; mantık olarak herbiri 1er saniye işlem görüp tekrar sıraya geçiyorlar. Taa ki işleri bitene kadar. Quantım 2 olsaydı eğer, herbiri 2 şer milisaniye işlem göreceğinden, işlem görme sürelerini de 2şer 2şer azaltacaktık.


Round Robin Sıralamasının Dezavantajı
Kesintili bir sıralama olmasından dolayı kısa süre içerisinde merkezi işlem birimi sürekli olarak farklı bir prosesi işliyor. Bu da her defasında bağlam değiştirme yapması anlamına geliyor. Daha önceki yazılarımda da belirttiği gibi, işlemcinin çok fazla bağlam değiştirme yapması olayı işletim sistemi için zaman açısından maliyetlidir.


Son olarak ufak bir.... NOT : Ben konuda örnek daha kolay anlaşılsın diye Quantum sayısına 1 milisaniye dedim. Oysaki gerçek şartlarda bir bilgisayar, 1 milisaniyede milyonlarca proses işlemi gerçekleştirebilir. Yani işletim sistemlerinde belirlenen o quantum sayısı 1 milisaniyeden çok çok daha küçük bir değerdir aslında.

Konuyla ilgili aklınıza takılan yerleri, görüşlerinizi veya düşüncelerinizi aşağıdaki yorum formu aracılığıyla bana iletebilirsiniz. Aklınıza takılan yerler var ise, size elimden geldiğince yardımcı olmaya çalışırım.
Yazının devamını oku
FIFO'nun açılımı Firt İn First Out ifadesidir. Türkçe'de ise bu ifade "İlk Giren İlk Çıkar" anlamına gelmektedir. FIFO sıralaması, bilgisayarımızın merkezi işlem birimi olan CPU'da işlem görmek isteyen proseslerden, bekleme kuyruğuna ilk önce gelen prosesin öncelikli olarak işlem görmesi mantığına göre çalışır.

FIFO sıralaması kesintisiz bir sıralamadır. Yani CPU'ya gelen bir prosesin işi bitmeden başka bir proses işlem göremez anlamına gelmektedir.


FIFO sıralamasını bir bankanın kuyruğuna benzetebilirsiniz. Kuyruğa ilk önce gelen müşteri, işlem görür ve işi bitene kadar da kuyruktan ayrılmaz. İlk gelenin işi bitip gittikten sonrasında ise, bir sonraki bekleyene sıra gelir. FIFO sıralaması da aynen bu mantıkla çalışan bir sıralamadır.

FIFO Sıralamasının Dezavantajı
Her prosesin işlem göreceği süre farklıdır. Bu sebeple prosesler arası boş ve gereksiz beklemeler çok olur.

Örneğin en öndeki A prosesinin işini bitirmesi için 10 saniye işlem görmesi gerektiğini düşünüelim. Oysaki arkadaki B prosesi 1 saniye işlem görse işini bitirecektir ama; FIFO mantığına göre ilk önce A prosesi işlem görmesi gerektiği için, B prosesi boş yere 10 saniye bekleyecektir. Bu işletim sisteminin hızlı çalışma prensibi açısından olumsuz bir durum oluşturur. Bu sebeple işletim sistemlerinde FIFO yöntemi tek başına tercih edilmez ve diğer yöntemler ile beraber kullanılır. Örneğin, farklı bir öncelik gerekçesi gerektiren bir yötemde, aynı önceliğe sahip proseslerin kendi aralarında sıralanması için kullanılabilir.

Yazının devamını oku
Daha önceki yazılarda bir prosesi ancak başka bir proses yaratabilir dedik ve bir prosesin fork() çağrısıyla başka bir prosesi yaratması sonucu bir program için birden çok proses paralel olarak çalışabilir dedik fakat; proses oluşturmak işletim sistemi için bazı sebeplerden dolayı çok maliyetli bir iştir. Bu sebeple bir programın birden çok işlem yapması gerekiyorsa eğer birden fazla proses üretmesi yerine Thread yani iplik kullanımının işletim sistemi açısından daha avantajlı olduğunu söylemiştik. Buraya kadar yazdığım ve belirttiğim herşeyin sebeplerini öğrenecez bu yazıda.

Bir program çalışırken ana prosesin yeni bir proses yaratması yerine bir iplik yaratması neden daha avantajlı. İplikler de prosesler gibi çalışırlar fakat hafif proseslerdir dedik. İplikler de prosesler gibi çalışıyorlarsa iplikler ile prosesler arasında farklar nelerdir? Bunlara değineceğiz.

İpliklerin Özellikleri ve Proses'ten Farkları

  • Thread'ler, proses içinde bulunurlar ve aynı adres uzayını paylaşırlar. Bir proses içerisinde birden fazla iş yürütebilirler.
  • İplikler prosesler gibi birbirlerinden bağımsız değildirler. Kendi aralarında kaynakları ve bazı verileri birbirleriyle paylaşırlar. 

Bakınız :

Yani kısacası; 
İşler birbirinden tamamen bağımsız ise : PROSES
İşler birbirine bağlı ve birlikte yürütülüyorsa : THREAD (İplik)  diyebiliriz.


İpliklerin Prosesler İle Olan Ortak Özellikleri:

  • Paralel çalışabilirleri etkileşebilirler ve haberleşebilirler.
  • Dış dünya ile haberleşebilirler.
  • Ardışıl işlemler yapılabilir.
  • İplikler de prosesler gibi bağlam(durum) değiştirebilirler. Hazır, Askıda, Çalışıyor durumlarda olabilirler.


İpliklerin Proseslere Göre Avantajları

  • Tek bir proses bile birden fazla işlem yapabilir. Böylece işlemcide daha az bağlam değiştirme olayı gerçekleşir. Sırada olan daha az proses olur ve bilgisayar işlemleri daha çabuk gerçekleştirebilir. Her işlemde proses kontrol bloğu yeniden güncellenmez. İşletim sistemi işlemleri gerçekleştirirken zaman kaybı yaşamaz.
  • Çok işlemcili sistemlerde faydalıdır. İpliklerin bazıları işlemciye yönelik işlemler yaparken bazıları giriş -çıkış işlemleri yapıyorsa yapılan iş için daha iyi performans elde edilir.
  • Proseslerin kaynakları vardır. İşletim sisteminde yer işgal ederler. Ne kadar çok proses olursa RAM'de o kadar çok yer işgal edilir. İpliklerin ise kaynakları yoktur. Mevcut prosesin sahip olduğu kaynağı kullanılar. Fazladan yer işgal etmezler. Yaratılmaları ve yok edilmeleri proseslere göre daha kolaydır.

Daha önceki yazımda şunu demiştim;
Bir programı birden çok prosesin çalıştırmasının avantajları ve dezavantajları vardır. Avantajı; bir programın çalışması için birden çok proses çalıştığı için o program kısa sürede işleme girebilir. Yani bir binayı birden çok işçinin inşa etmesi gibi fakat; bunun şöyle bir dezavantajı var. Ne kadar çok proses olursa, bilgisayarın RAM'inde o kadar yer işgal edilecektir ve CPU bir program için birden fazla proses işleyeceği için bu bilgisayarı daha çok yoracaktır. Kısacası bellek tahsisi, bağlam değiştirme veya anahtarlanma işlemleri sırasında yüklenmeleri işletim sistemi açısından daha maliyetli olur.

İplik denen olay işte tam da burada devreye giriyor. Yani tam olarak demek istediğim şey şudur. İşletim sisteminde bir iş için 3 ayrı prosesin çalışması yerine, tek bir prosesin çalışıp içinde 3 iplik bulundurması ile aynı işlemler  gerçekleştirilebilir. Proses işlemlerini işletim sistemleri CPU'da işlerken, yukarıda da saydığımız bazı sebeplerden dolayı (bağlam değiştirme olayı vs. ) maliyetli olması sebebiyle, işletim sisteminde bir iş yaparken çok fazla proses kullanmak yerine daha az proses ve daha çok iplik kullanmak, daha çok tercih edilir.

Özetle, aynı örnek üzeriden konuşacak olursam. Tek proses ve bu proses içinde 3 iplik barındırarak çalışan bir program, 3 farklı proses ile çalışan programa göre, işletim sistemi açısından çoğu zaman avantajlıdır. Bu sebeple bir işlem için çok fazla proses kullanmak yerine, tek proses kullanıp ve tek prosesin içinde iş bölümü yapacak olan birden çok iplik yaratıp kullanmak daha mantıklıdır.
Yazının devamını oku
İplikler hafif proses olarak adlandırılırlar. Prosesler gibi çalışırlar ama proseslere göre belli başlı farkları vardır. Ona da farklı bir başlık altında değineceğim. Türkçesi iplik olan bu hafif prosesler, ingilizce ifadesi olan Thread olarak da geçer bazı kitaplarda veya web sitelerinde.

İplikler, tek bir prosesin daha çok işlem yapmasına olanak tanırlar. Bilgisayar belleğinde fazladan alan işgal etmezler. Belli bir alana sahip proseslerin içinde çalışırlar. Bir proses bir ipliğe sahip olabileceği gibi birden fazla ipliğe de sahip olabilir.




İplikler kolay oluşturulup kolay yok edilirler.  Bir program yazarken, programın mevcut prosesi içinde bir iplik yaratıp birden çok işlem yapmak istiyorsanız eğer, derleyicinize;

#include <pthread.h>

kütüphanesini eklemeniz gerekiyor.

Threadler yani iplikler ile işlemler yaparken bazı ifadeleri bilmeniz gerekiyor. İplikler ile işlem yaparken bu ifadeler olmazsa olmaz ifadelerdir. Programı yazmaya başladığınız zaman main kısmında öncelikli olarak yapacağınız işlemlerdir. Kısacası bu ifadeler iplik işlemlerinin demirbaş işlemleridir.

pthread_t()

İpliklere ait bilgileri tutar. Bir ipliğin sahip olması gereken tüm özellikler bu ifade ile tanımlanmış olan ifadede saklanır.

pthread_create() :

 Bu ifade ile yeni bir iplik oluşturulur. 4 farklı parametre alır.
1. parametresi : İpliğe ait bilgileri tutan değişkenin adresini tutar.
2. parametresi : İpliğin özelliklerini tutar. Yapacağımız örneklerde NULL olarak kalacak.
3. parametresi : İpliğe ait olan fonksiyonun adını tutar.
4. parametresi : İpliğimize ait olan fonksiyona değer döndereceksek eğer, 4. parametre kısmı kullanılır. Bu parametre için unutmamanız gereken en önemli özellik ise, bu parametre sadece void değerler alır. Eğer ki farklı türdeki değerler yollayacaksanız fonksiyona, ilk önce (void *)x işlemi yaparak değerinizi void türüne dönüştürmeniz gerekiyor. Videolarda bunu daha iyi anlayacaksınız zaten.

pthread_join() 

"İpliğin işlemini bitirmesini bekle" anlamına gelir. Eğer iplik kullanarak bir program yazacaksanız bu ifade olmazsa olmaz bir ifadedir. Bu ifade sayesinde iplik işini bitirmeden proses sonlanmaz. Bu ifade 2 parametre alır.

1. paremetresi : İpliğe ait bilgileri tutan değişkenin kendisini tutar.
2. parametresi : Geri dönüş değerlerini tutar. Eğer ipliğinizin geri dönüş değeri var ise, ikinci parametre bu veriyi tutar. Yarattığınız thread geriye değer döndermiyor ise eğer, bu parametreye NULL yazılır.

pthread_exit()

İçine void değerler alır. İpliğin geri dönüş değerini tutarlar. Geri dönüş değeri yok ise içine NULL yazılır.


İplikler nedir, nasıl çalışırlar, iplik oluşturup çeşitli işlemler nasıl yapılır? Bütün bunları daha iyi anlamanız açısından iplikler ile ilgili 4 tane örnek video çektim.

1. Örnek : Bu örnek basit bir thread örneğidir. İpliklere değer gönderme falan yok. Basit olarak threadlerin genel yapısını görmenizi sağlayacak bir örnektir. Örnekte her fonksiyonu bir iplik olarak düşüneceğiz.


2. Örnek :  Bu örneğin bir öncekinden farkı, bu sefer ipliğimize değer gönderiyoruz. Yine önceki örnekte olduğu gibi her fonksiyonu bir thread olarak düşünecez.


3. Örnek : Artık örneklerimizin gelişmişlik düzeyi giderek artıyor. Bu videoda Thread'lerin değer döndermesini göreceğiz. pthread_join() ifadesinin nasıl kullanıldığını göreceksiniz. Her fonksiyon bir thread olarak düşünülecek.


4. Örnek : Diğer 3 örneğe göre en gelişmiş olan örnektir. Bu örnekte bir yapı kullanacağız. Kullanacağımız bu yapı sayesinde bir Thread'e (ipliğe) birden çok veri gönderebileceğiz ve oluşturacağımız her iki Thread, tek bir fonksiyonu kullanacaktır. Üstelik de ipliğimiz değer dönderen bir iplik olacaktır.

Yazının devamını oku

Oluşturduğumuz prosesler veya mevcut proseslere, bazı sistem çağrıları ile istediğimiz yaptırabiliyoruz. Bugün ise başlıktan da anlayacağınız üzere "Bir Prosesi Öldürme, Bekletme, Uykuya Alma ve Yeniden Başlatma" çağrılarını tanıtacağım kısaca.

Kodlar, kütüphaneler C dili kütüphaneleridir. Çağrıları ise Linux işletim sistemine ait sistem çağrılarıdır.

Bekleme ve Sonlanma Çağrıları

Bu çağrıları kullanabilmek için derleyicimize,

#include <sys/types.h>
#include <sys/wait.h>

kütüphanelerini eklememiz gerekiyor.

Sleep() Çağrısı

Herhangi prosesi, parantezler içerisine yazacağımız saniye kadar bekletebiliriz. Hangi prosesi bekleteceğiniz ise tamamen size kalmış. Mesela çocuk proses aktif olacağı sırada ben program koduma sleep(1) yazdım diyelim. Bu durumda çocuk prosese sıra geldiği zaman çocuk proses çalışmayacak. 1 saniye bekleyecek. Bu sırada başka proseslerin işleri varsa onlar işlerini yaparlar ve 1 saniye sonra çocuk proses yeniden aktif olur. Yani sleep(1) yaparak istediğimiz herhangi bir prosesi 1 saniyeliğine uyutmuş oluruz. Eğer ki sleep(5) yazarasak, o anda aktif olan proses 5 saniyeliğine uyku moduna geçer ve bu süre dolana kadar da aktif olmaz. Süre dolduktan sonra tekrar kendiliğinden uyanır ve işlemlerine devam eder. Bilgisayardaki işlemler milisaliseler içerisinde gerçekleştiği için 1 bile saniye aslında önemli bir zaman aralığıdır.


Wait() ve Waitpid() Çağrıları

Bu ifadeyi aktif olan proses içine yazdığımız zaman o proses, herhangi bir alt prosesin işlemini bitirmesi için bekler. Sonlanmadığı için programı da sonlandırmaz. Yani proses vardır ama işlem yapmıyordur diyebiliriz. Diğer prosesin işini yapmasını bekler. İpliklerde pthread_join() ifadesi bu görevi görüyordu. Proseslerde ise wait() ve waitpid() çağrıları bu görevi yapar.

wait(int *durum) şeklinde tek bir parametre alır içine. Bu parametre adres tutar. Beklenen proses sonlandığında, sonlanan bu prosesin çıkış değerini tutar. wait() çağrısı, waitpid() çağrısının eski versiyonudur.

Waitpid(pid_t pid, int *durum, int secenekler); şeklinde 3 parametre alır.
Birinci parametreye bekletmek istediğimiz prosesin ID numarasını yazıyoruz.

1. parametre : Hangi prosesi bekleyeceksek onun ID'sini yazıyoruz. Herhangi bir çocuk proses beklenecekse ilk parametreye "-1" değeri girilir.
2. parametre : Bu parametre adres tutar. Beklenen proses sonlandığında int *durum olarak belirttiğimiz ikinci parametre ifadesi, sonlanan bu prosesin çıkış değerini tutar.
3. paramtere : Özellikler parametresidir. "0" veya bazı özel değerler alır. Sıfır yazmadığımız durumlarda alabileceği bu bazı özel değerlerin 3 tanesine bakalım :

WNOHANG     : Hiçbir çocuk proses sonlanmıyorsa hemen geri dönmeyi belirtir.
WUNTRACED : Çocuk proses durdurulduğunda geri dönülecektir.
WCONTINUED:Durdurulan çocuk proses SIGCONT sinyali aldığında geri döner.



SİNYAL ÇAĞRILARI


Buraya kadar yazdıklarım Bekleme ve Sonlanma Çağrıları'ydı. Şimdi ise proseslerdeki bazı sinyal alma çağrılarına bakalım.

Sinyal çağrıları içi kullanılması gereken kütüphane;
#include <signal.h>

Sinyal çağrılarından sadece kill() ifadesine değineceğim için en başından şunu belirtmeliyim ki bu çağrı;

kill(pid_t pid, int signal);

olmak üzere 2 parametre alır. İlk parametre proses ait bilgileri tutar. İkinci parametre ise sinyal bilgisini tutar. O proses ne yaptırmak istiyorsak, signal kısmına o sinyalin adını yazmamız gerekiyor. Alttaki ifadelerden de ne demek istediğimi daha iyi anlayacaksınız.

pid_t prosesID; //olsun.
prosesID = fork(); //çocuk prosesin bilgileri artık "prosesID" ifadesi içinde saklanıyor.

Artık "prosesID" ifadesini kullanarak, çocuk prosese kill() aracılığıyla istediğimiz sinyali uygulayabiliriz.

kill(prosesID,SIGSTOP) ve kill(prosesID,SIGCONT) Çağrıları

Bu ifadeler sayesinde, ID numarasını bildiğimiz bir prosesin işlemini istediğimiz zaman sonlandırıp, istediğimiz zaman yeniden aktif edebiliyoruz. Mesela şöyle bir örnek vereyim. Çocuk prosesin ID numarasının "prosesID" olduğunu varsayalım. Ben kill(prosesID,SIGSTOP) ifadesini kullanırsam eğer, çocuk proses duracaktır ve hiçbir iş yapamayacaktır. Taa ki biz yeniden kendisini aktif edene kadar. kill(f,SIGCONT) ifadesi ise işte burada devreye giriyor. SIGSTOP komutu ile işlem yapmasını durdurduğumuz bir prosesi SIGCONT komutu ile istediğimiz zaman yeniden aktif hale yani iş yapabilir hale getirebiliyoruz.



kill(prosesID,SIGKILL) Çağrısı

Bu ifade ile ID numarasını bildiğimiz bir prosesi istediğimiz zaman öldürebiliyoruz. Öldürdüğümüz proses bir daha işlem yapamaz ve eğer ana proses ile programın sonlanmasına sebep olur. Öldürmek istediğimiz ana prosesin ID numarasının "prosesID" olduğunu varsayalım. Bu durumda kill(f,SIGKILL) olarak kullanılır bu ifade.


Derlediğiniz programda ID numarası yazılması gereken kısım olan "prosesID" kısmında "getpid()" ifadesini kullanabilirsiniz.
  • kill(getpid(),SIGSTOP)
  • kill(getpid(),SIGCONT)
  • kill(getpid(),SIGKILL)
vs. gibi.


Bu konuyla ilgili anlatacaklarım bu kadar. Konuyla ilgili aklınıza takılan tüm soru, öneri, ve isteklerinizi aşağıdaki yorum formundan belirtebilirsiniz.
Yazının devamını oku
Proses konusunun devamı olan Fork() sistem çağrısından bahsedeceğim. Eğer daha önceki yazımı okumadıysanız ilk önce buraya tıklayarak o yazımı okumanızı tavsiye ederim.

Daha önceki yazımı okuduysanız orada bahsetmiştim. Bir program bir yada birden fazla proses tarafından çalıştırılabilir. Bir programın birden fazla proses tarafından çalıştırılması demek, tek bir prosesin yapacağı işi, birden fazla proses yaparak o programın daha kısa sürede ve daha hızlı bir şekilde çalışmasına yardımcı olduğundan bahsetmiştik. Yani bir binayı bir işçi yerine birden çok işçinin inşa etmesi nasıl ki o inşaat işinin daha kısa sürede tamamlanmasını sağlıyorsa, bunu da ona benzetebilirsiniz. Çünkü aynı anda birbirine paralel olan işler yürütülebilmektedir. Anne proses bir iş ile ilgilenirken çocuk proses aynı zamanda daha başka bir iş ile ilginiyor olabilir veya aynı işi yapıyor olabilirler yada bir diğerini bekliyor da olabilirler. Birebir aynı olduğu gibi farklı bir proses de olabilir. Biz bunu kullanacağım sistem çağrıları ile ayarlayabiliyoruz.

Fork() Çağrısı Nedir?

Bir programın çalışmasına yarayan bir prosesin kopyasının oluşturulması işlemidir. Yani kısacası yeni bir proses oluşturma işlemidir. Oluşan bu kopya prosese çocuk proses denir. Bu çocuk proses kimden kopyalandıysa, kopyalandığı o proseses ise Anne prosestir. Bu sistem çağrısı ile oluşan ikinci kopya prosesin yani çocuk prosesin tüm özellikleri, kod belleği birebir anne proses ile aynıdır.




Program koduna yazdığımız fork() ifadesinden sonra hem anne proses hem de çocuk proses aynı işlemi yapar.

Örneğin ben derleyiciye printf("Merhaba Dünya\n"); yazdırdım. Eğer ben bu tırnak içerisindeki kelimeyi fork() çağrısından sonra yazarsam, 2 defa "Merhaba Dünya" yazılır ekrana. Çünkü yazma işlemini hem çocuk proses yapıyor hem de anne proses yapıyor. Kullanacağımız sistem çağrıları yardımıyla çocuk prosese başka işler yaptıra da biliriz.

Aynı program içerisinde aynı işi yapan bu 2 prosesin herbirine farklı işler yaptırmak için hangi prosesin çocuk, hangi prosesin ise anne proses olduğunu bilmemiz gerekiyor. Bunu da anlamak için, proseslerin dönüş değerini bilmemiz yeterlidir. fork() dediğimiz çağrı ile çocuk proses "0" değeri atanır. Anne prosese ise "0" dan farklı bir numara atanır.

Bu aşamadan sonrası için bir video çektim. Daha iyi anlamanız açısından fork() çağrısı ve proseslerin detaylı anlatımı için bir video hazırladım.




Konu ile ilgili alıntı yaptığım ek bir bilgi : Ufak tefek işleri parent yaparken, bütün ameleliği çocuk prosese yükler. Oturup gazete okuyan bir babanın çocuğundan durmadan çay,terlik,yastık vs istemesi gibi bir şey bu. Bu olay proses'in daha hızlı işlem yapmasına olanak sağlar çünkü işleyiş iki koldan ilerler. İşleyiş olarak multithread olayına benzer ama temelde tamamen farklıdırlar.
Yazının devamını oku
Proses kelimesi ingilizcedeki process kelimesinden gelmektedir. Süreç, işlem gibi anlamlara gelmektedir. Bilgisayarımızın da merkezi işlem biriminde (CPU) çalışan işlemler yani prosesler vardır. Bu proseslerin kimisi işletim sisteminizi çalıştırmaya yararlar, kimiler ise kullandığınız diğer masaüstü programları çalıştırmaya yararlar. Tarayıcı, Media Player, ofis programları vs. gibi tüm programlar aslında birer prosestir ve kendi altında birden çok proses de bulundurabilirler.

  • Özet Bilgi : Karıştıranlar için şimdiden belirteyim. CPU, MiB ve İşlemci kelimeleri aynı şeylerdir. Bilgisayarın beynine verilen isimlerdir bunlar. Tüm veriler, programlar ve işlemler burada gerçekleşir. CPU, Central Unit Process anlamına gelir. MİB de bunun Türkçesi olan Merkezi İşlem Birimi anlamına gelir. Yazıyı okurken bu ifadeleri sık sık kullnacağım.

Bilgisayarda kullandığınız her program, bilgisayarın işlemcisindeki prosesler aracılığıyla çalışırlar. Örneğin siz müzik dinlemek için Windows Media Player'a tıklayıp açmak istediniz. Tıkladığınız sırada Windows Media Player'ın çalışmasına yarayan prosesler hemen devreye girerler ve bilgisayarın işlemcisine gelip işlem görürerler. Bilgisayar'da Media Player'ı açar. Bilgisayarlar o kadar hızlı çalışırlar ki bu işlemler milisaniyeler içinde meydana gelir.

Şimdide proseslere biraz daha somut olarak bakalım. Ctrl+Alt+Delete yapın ve görev yöneticisini açın. Üstteki sekmelerden "İşlemler" yazan kısma gelin. Bu kısımda gördükleriniz proseslerdir.


 
Alt kısımdaki "işlemler" yazan kısma dikkat edin. Benim bilgisayarımda şuanda aktif olarak çalışan 74 proses varmış.

Proses listesi açık iken masaüstünüzden herhangi bir program açıp kapatın. Açtığınız zaman o programa ait proses yada prosesler orada gözükeceketir. Kapattığınız zaman kaybolacaklardır. Bazı programlar için tek bir proses görülebilirken bazı programlar birden çok proses tarafından çalıştırılırlar. Örneğin yukarıdaki ekran görüntüsünde Google Chrome'un 4 farklı proses tarafından çalıştığını görebilirsiniz. Biraz daha alt kısımda yer alan Firefox'un tek bir proses tarafındna çalıştığını görebiliriz. Fakat sadece buna bakarak hangi programın daha iyi olduğuna karar vermeyiniz. Belkide içlerinde bulunan iplik sayıları farklıdır. İplik konusuna daha sonraki yazılarımda değineceğim.

Bir programı birden çok prosesin çalıştırmasının avantajları ve dezavantajları vardır. Avantajı; bir programın çalışması için birden çok proses çalıştığı için o program kısa sürede işleme girebilir. Yani bir binayı birden çok işçinin inşa etmesi gibi fakat; bunun şöyle bir dezavantajı var. Ne kadar çok proses olursa, bilgisayarın RAM'inde o kadar yer işgal edilecektir ve CPU bir program için birden fazla proses işleyeceği için bu bilgisayarı daha çok yoracaktır.

Şimdi proses durumlarını anlatayım. Neden işlemciyi daha çok yorduğunu ve ne demek Proseslerin Durum (Bağlam) Değiştirmesi kısmında daha iyi anlayacaksınız.

Proses Durumları

Prosesler hazır, bekleme ve çalışma durumlarında bulunabilirler.


Çalışma Durumu : Prosesin CPU'da işlem gördüğü durumdur.
Hazır Durumu     : Prosesin hazır olduğu ve çalışmak için (CPU'dan işlem görmek için) sırasının gelmesini beklediği durumdur.
Askıda Durumu   : Prosesin hazır duruma geçmek için bir olayın gerçekleşmesini beklediği durumdur.

Örneğin; hesap makinası programını açtınız. Açtığınız anda onu çalıştıran proses önce hazır kuyruğuna geçer, sonra işlemcide işlem görerek çalışma durumuna geçer ve program açılır. Tabi bunlar çok hızlı bir biçimde, milisaliseler içerisinde gerçekleşirler.  Daha sonrasında ise hesap makinesi programını çalıştıran proses, "Askıda Durumu"na geçer. Sizden rakam bekler. Siz rakam girip bir işlem yapmadığınız sürece o hep askıda kalır. Daha doğrusu askıda kuyruğuna geçer. Çünkü birden fazla proses askıda bekliyor olabilir. Bu sırada işlemcide başka bir program işlem görüyordur. Siz rakam girdiniz diyelim veya direkt olarak 3 + 2 yazdınız diyelim. (Tek tek uzun uzun anlatmamak için direkt olarak 3+2 dedim. Normalde 3 ve + ve 2 ayrı ayrı işlemlerdir.)
Program bu süre içerisinde yukarıda yazdığım işlemleri tekrar eder. Askıdan çıkar --> Hazır Kuyruğuna geçer --> Çalışır durumuna geçer. Çalışır durumunda size bir şey yansımaz ama o girdiğiniz ifadeleri bilgisayar kendi beyni olan CPU'da işler ve tekrar askıya geçer. Sizden tekrar bir işlem bekler. Askıda olduğu sürece işlem yapmaz. Siz eşittir yaptığınız sırada işlemler tekrar eder. Askıdan Kuyruğundan çıkar  --> Hazır Kuyruğuna geçer --> Hazır Kuyruğundan çıkıp --> Çalışır duruma geçer ve ekrana 5 sonucunu yazar.

Neden Hazır Kuyruğu veya Askıda Kuyruğu diyorum? Çünkü bilgisayarda birden çok proses vardır ve herbir proses işlemcide tek tek işlem görür. Yani uzun bir bilet kuyruğu düşünün. 1 tane gişe olduğunu düşünün. Gişe, işlemcidir. Kuyrukta hazır bekleyen insanlar ise birer proses olarak düşünülebilir. Tabi bu proseslerin kimisi askıda kuyruğundadır kimisi ise hazır kuyruğunda bekliyor olabilir. Kimisi ise işlem görüyordur.

Her Proses Kendi İle İlgili Olan Kuyruğa Girer!

Bu kısım önemli. Tüm programlar Merkezi İşlem Birimi'nde (MiB)'de yani CPU'da işlem görmeden önce, henüz askıda durumundayken, herhangi bir kuyruğa girmez. Kendi ile ilgili olan kuyruğa girer. Çünkü bazı programların çalışması daha uzun sürebilir bazı programların çalışması daha kısa sürebilir. Tüm prosesler aynı kuyruğa girerse, açılması daha kısa süren program, açılması daha geç olan programında arkasında sıraya girer ise, 1 saniyede açılacak olan program 10 saniyede açılabilir. İşletim sitemi geliştiriciler de bunun önüne geçebilmek için, benzer işlemleri yapan programları bilgisayar RAM'inde farklı farklı yerlerde kuyruğa girmesini sağlamışlardır.

Bakınız :



Bir Proses Neden Sürekli Çalışmayıp Askıda ve Bekleme Konumlarına Geçiyor?

Bilgisayarda hesap makinesi dışında onlarca çalışan program olduğunu Ctrl+Alt+Delelete yaparak  görmüştük. Her proses merkezi işlemci birimi olan CPU'yu yani bilgisayarın beynini işgal ederse ise sürekli, bilgisayar kitlenir. Bu sebeple işi biten proses işlemcide işlem gördükten sonra çıkmak zorundadır. Eğer proses tekrardan işlem görmek istiyorsan tekrardan hazır kuyruğuna geçer.


Prosesin Durum (Bağlam) Değiştirme Olayı

Proses Durum Değiştirirken Hangi İşlemler Gerçekleşir? Şimdi buna değinelim

Prosesler, içlerinde bir takım bilgiler barındırırlar.  Bu bilgiler Proses Kontrol Bloğu denen yerde tutulur. Bu proses kontrol bloğunda ise, şu bilgiler bulunur :



Proeses durum değiştirir iken... Yani; Hazır - Beklemede - Askıda durumları arası geçiş yaparken yukarıda sayılan PCB (proses kontrol bloğu) güncellenir. Tüm bu bilgilerin her durum değiştirme sırasında tekrardan güncellenmesi ise, işletim sistemi için zaman kaybıdır. PCB haricinde, durum değiştirme olayı sırasında proseslerde şu işlemler gerçekleşir :



Gördüğünüz gibi birden çok proses bir programı çalıştırırken o program için çalışma kolaylığı sağladığı gibi, dezavantaj olarak boş yere bilgisayar hafızasında yer kaplar ve işlemci daha çok işlem yapmak zorunda kalır. Bu da işlemcinin sırada bekleyen diğer işlemleri gerçekleştirmesi normalden daha uzun sürer.

FORK() Sistem Çağrısı

Bu çağrı yeni bir proses oluşturma çağrısıdır. Çalışan bir programa hizmet eden bir proses yerine birden çok prosesin hizmet etmesini sağlayabiliriz. Bu prosesler birnine paralel olarak çalışır. Örneğin çocuk proses başka bir prosesi çalıştırıp ona başka işlemler yaptırırken anne proses de kendi kendine başka işlemler yapabilir. Fork() olayı sayesinde oluşturacağımız proses ile aynı anda birbine paralel olarak çalışan birden çok işlem yapabiliyoruz. Fork sistem çağrısına bir sonaki yazımda ayrıntılı olarak değineceğim.

Konu ile ilgili aklınıza takılan tüm soruları aşağı kısma yorum olarak yazabilirsiniz. Size elimden geldiğince yardımcı olmaya çalışırım.
Yazının devamını oku

İstatistikler

BLOGKAFEM.NET

© Copyright 2008-2018
Sitedeki yazıların her hakkı BLOGKAFEM.NET sitesine aittir.
Kopyalanması halinde lütfen kaynak gösteriniz.
DMCA.com Protection Status
Anasayfa | Hakkımda | Bizden Haberler | Reklam | İletişim