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.

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.

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.

İ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.

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.