Threads Nedir? Aynı Anda Birden Fazla İş Yapabilen Programları Anlamak

Bazı programlar tek bir çalışan gibi davranır.

Bir işi yapar, onu bitirir, sonra sıradakine geçer.

Ama gerçek dünyada işler çoğu zaman böyle gelmez. Kullanıcı bir şey beklerken arka planda başka bir işlem devam eder. Bir yerde veri işlenirken başka bir yerde yeni görev oluşur. İşte bu noktada thread kavramı devreye girer.

Thread, bir süreç içindeki çalışma akışıdır. Bir süreç içinde tek bir thread varsa, program aynı anda yalnızca tek bir iş yürütüyor gibi davranır. Birden fazla thread varsa, aynı süreç içinde birden fazla görev ele alınabilir. Özellikle çok çekirdekli sistemlerde bu yapı daha da anlamlı hale gelir.

Neden thread kullanılır?

Çünkü bazı işleri tek çizgi halinde yürütmek verimsizdir.

Bir programın içinde birbirinden bağımsız görevler varsa, bunları ayrı thread’lere bölmek daha düzenli bir yapı sağlar. Böylece her şey tek sırada beklemek zorunda kalmaz. Özellikle birbirine bağlı olmayan görevler aynı süreç içinde ayrı akışlar halinde ilerleyebilir.

Bir başka faydası da şudur: Kullanıcıyla ilgilenen bölüm ile arka planda çalışan bölüm birbirinden ayrılabilir. Bu da etkileşimli programlarda daha iyi tepki süresi sağlar. Program tek parça ağır bir yapı gibi değil, görevlerini paylaştıran bir sistem gibi davranır.

Kısacası thread yalnızca hız için değil, daha temiz bir program yapısı kurmak için de kullanılır.

Bir thread’in kendine ait neleri vardır?

Bir thread yalnızca “çalışan kod parçası” değildir.

Onun da kendine ait bir kimliği vardır. Thread ID’si vardır. Kendi register değerleri vardır. Kendi stack alanı vardır. Zamanlama bilgisi, signal mask’i, errno değeri ve thread’e özel verileri de bulunur.

Ama işin önemli tarafı şudur: Aynı süreç içindeki thread’ler birçok şeyi ortak kullanır. Programın kodu, global bellek alanı, heap alanı ve dosya tanımlayıcıları gibi yapılar ortak paylaşılır.

Yani bir ofiste çalışan kişiler gibi düşünebilirsin.

Herkesin kendi masası olabilir ama bina ortaktır. Ortak alanlar paylaşılıyorsa, düzen konusu da önemli hale gelir.

Thread ID neden önemli?

Her thread’in bir kimliği vardır.

Ama bu kimlik, süreç kimliği gibi tüm sistemde geçerli bir etiket değildir. Thread ID daha çok ait olduğu süreç içinde anlam taşır. Yani aynı ekip içindeki çalışan numarası gibi düşünülebilir.

Bir thread kendi kimliğini alabilir ve bu kimlik bazen görev dağıtımında işe yarar. Mesela bir ana thread, işleri bir kuyruğa koyup hangi işin hangi çalışan thread’e gideceğini bu kimlik üzerinden takip edebilir.

Bu küçük detay, thread mantığını daha görünür kılar: aynı sürecin içinde birden fazla işçi vardır ve bazen kimin hangi işi yapacağını ayırmak gerekir.

Thread oluşturmak ne demek?

Bir program başladığında genelde tek süreç ve tek thread ile başlar.

Yani ilk hali oldukça sade görünür. Ama yeni thread’ler oluşturuldukça aynı süreç içinde birden fazla akış ortaya çıkar. İşte bu andan sonra program artık tek çizgili değil, çok akışlı bir yapıya dönüşür.

Burada önemli bir nokta var: Yeni bir thread oluşturulduğunda ilk önce hangisinin çalışacağı kesin değildir. Yeni thread mi önce koşacak, yoksa onu oluşturan mevcut thread mi, bu garanti edilmez.

Bu yüzden thread dünyasında program akışını düşünme biçimi değişir. Artık her şey tek sırada ilerlemiyordur.

Thread nasıl sona erer?

Bir thread’in bitmesi ile tüm sürecin bitmesi aynı şey değildir.

Bir thread kendi akışını tamamlayabilir, ama süreç yaşamaya devam edebilir. Bir thread başlangıç rutininden geri dönebilir, başka bir thread tarafından iptal edilebilir ya da kendi çıkış çağrısını yapabilir.

Ama burada dikkat edilmesi gereken önemli bir durum vardır: süreç düzeyinde sonlandırıcı bir çıkış çağrısı yapıldığında, yalnızca bir thread değil, tüm süreç sonlanabilir.

Yani thread’lerle çalışırken “bu akış biterse ne olur?” sorusu önemlidir. Çünkü bazen yalnızca bir işi kapatmak isterken bütün yapıyı kapatmış olabilirsin.

pthread_join neden önemlidir?

Thread başlatmak işin yarısıdır.

Diğer yarısı, onun düzgün şekilde tamamlanmasını beklemektir.

Bir thread işini bitirdiğinde onu toplamak, sonucunu almak ve kaynaklarını düzgünce kapatmak gerekir. pthread_join mantığı tam burada anlam kazanır. Yani “bu thread bitsin, ben de onunla düzgün şekilde buluşayım” demektir.

Bu, dağınık bir kapanış yerine kontrollü bir bitiş sağlar.

Asıl sorun ne zaman başlar?

Thread’ler aynı belleği paylaşmaya başladığında.

Eğer her thread yalnızca kendi verisiyle uğraşıyorsa işler genelde sakindir. Aynı veri sadece okunuyorsa yine büyük bir problem çıkmayabilir. Ama bir thread veriyi değiştirirken başka bir thread de aynı veriye bakıyor ya da onu değiştirmeye çalışıyorsa, işte o zaman tutarsızlık riski başlar.

Sorun tam olarak burada ortaya çıkar: iki thread aynı şeye aynı anda dokunmaya çalışırsa sonuç her zaman beklediğin gibi olmayabilir.

Bu durum özellikle ortak bir değişken üzerinde yapılan işlemlerde daha net görülür.

“Bir artırma işlemi” bile neden risklidir?

Çünkü dışarıdan tek hareket gibi görünen bazı işlemler, içeride aslında birkaç adımdan oluşur.

Örneğin bir değeri artırmak çoğu zaman şu mantıkla olur: önce mevcut değer okunur, sonra artırılır, sonra geri yazılır.

Şimdi iki thread’in bunu aynı anda yaptığını düşün.

İkisi de eski değeri görürse, ikisi de kendi artışını onun üstüne kurar. Sonuçta iki artış beklerken tek artış görmüş olabilirsin. Yani sorun matematikte değil, zamanlamadadır.

Thread programlamasında en zorlayıcı noktalardan biri budur: bazen yanlış sonuç, kodun yanlış olmasından değil, aynı anda doğru görünen iki şeyin çarpışmasından çıkar.

Senkronizasyon neden gerekir?

Çünkü paylaşılan veri için sıra gerekir.

Birden fazla thread aynı kaynağa erişiyorsa, herkes aynı anda içeri dalmamalıdır. Bazen bir thread’in işlemini tamamlaması, diğerinin beklemesi gerekir. Böylece herkes verinin tutarlı halini görür.

Eğer işlem gerçekten atomikse, yani bölünmeden tek adım gibi gerçekleşiyorsa sorun çıkmayabilir. Ama birçok durumda özellikle değiştirme işlemleri için koruma gerekir.

İşte senkronizasyonun amacı budur: thread’leri durdurmak değil, birbirlerini bozmadan çalıştırmak.

Mutex nedir?

Mutex, en basit haliyle bir kilittir.

Paylaşılan kaynağa girmeden önce kilidi alırsın. İşin bitince kilidi bırakırsın. Sen içerideyken başka bir thread aynı yere girmeye çalışırsa beklemek zorunda kalır.

Bu yüzden mutex’i kapıya asılan “şu an meşgul” tabelası gibi düşünebilirsin.

Mantık çok nettir: aynı anda yalnızca bir thread kritik bölgeye girsin.

Bu, özellikle ortak değişkenleri korumada çok işe yarar. Kilit varsa karmaşa azalır. Kilit yoksa şans devreye girer. Thread programlamasında da en tehlikeli şeylerden biri, programın doğru çalışmasını şansa bırakmaktır.

Bir thread bekleyemeyecek durumdaysa, kilidi zorlamadan sadece uygun olduğunda almaya çalışan yaklaşım da vardır. Bu durumda thread “kilit boşsa alayım, doluysa bloklanmadan yoluma bakayım” mantığıyla ilerler.

Mutex kullanmazsan ne olur?

En büyük risk, ortak verinin beklenmedik hale gelmesidir.

İki thread aynı sayacı artırıyor olabilir. İkisi de aynı görevi yapıyor gibi görünür. Ama senkronizasyon yoksa sonuç bazen tutarlı çıkar, bazen çıkmaz. Program bir çalıştırmada normal görünür, başka bir çalıştırmada tuhaf davranabilir.

İşte bu yüzden mutex kullanımı, yalnızca teorik bir güvenlik önlemi değil, pratikte programın davranışını sağlamlaştıran bir araçtır.

Semaphore neden ayrıca önemli?

Mutex en sade araçlardan biridir.

Ama bazen daha güçlü, daha esnek bir yapıya ihtiyaç olur. İşte burada semaphore devreye girer.

Semaphore da senkronizasyon için kullanılır ama daha zengin bir mantık sunar. Sayaçla çalışan bir kontrol mekanizması gibi düşünülebilir. Bu yüzden mutex ile benzer görünse de kullanım alanı daha geniştir.

Basit bir benzetmeyle söylersek, mutex tek anahtarlı bir kapı gibidir. Semaphore ise kaç kişinin aynı anda geçebileceğini sayıyla yöneten bir sistem gibidir.

Burada en kritik nokta yine aynıdır: bu sayının değiştirilmesi güvenli olmalıdır. Çünkü senkronizasyon araçları bile kendi içinde korunmazsa, çözüm olması gereken şey yeni bir problem haline gelir.

Sonuç

Thread’ler programlara aynı anda birden fazla şey yapabilme yeteneği kazandırır.

Bu, daha iyi tepki süresi sağlayabilir. Program yapısını sadeleştirebilir. Görevleri bölmeyi kolaylaştırabilir. Ama aynı zamanda yeni bir sorumluluk getirir: paylaşılan veriyi dikkatle yönetmek.

Bu yüzden thread konusu yalnızca “nasıl oluşturulur?” sorusundan ibaret değildir.

Asıl soru şudur:
Birden fazla akış aynı yapının içinde birbirine çarpmadan nasıl çalışır?

Bu sorunun cevabı da bizi senkronizasyona, mutex’e ve semaphore’a götürür.

Yani thread programlaması aslında kalabalık bir ekibi yönetmek gibidir.

Herkese iş vermek kolaydır.
Asıl mesele, herkesin aynı anda birbirinin işini bozmadan çalışmasını sağlamaktır.