🚀 BAŞTAN SONA RUST DİLİ BÖLÜM-16: Concurrency (Eşzamanlılık) ve Paralel Programlama ⚡

🚀 BAŞTAN SONA RUST DİLİ BÖLÜM-16: Concurrency (Eşzamanlılık) ve Paralel Programlama ⚡

Selamlar! Serimizin 16. bölümüne hoş geldiniz.

Önceki bölümde `Box<T>`, `Rc<T>` ve `RefCell<T>` gibi Smart Pointer yapılarını detaylarıyla öğrenmiştik. Bu bölümde ise günümüz yazılım dünyasının en kritik konularından biri olan **Concurrency (Eşzamanlılık)** ve **Paralel Programlama** konularını inceleyeceğiz.

Rust'ın bu konudaki mottosu: **Fearless Concurrency (Korkusuz Eşzamanlılık)**'tır. C/C++ gibi dillerde paralel kod yazarken sıkça karşılaşılan Data Race (Veri Yarışı), Deadlock ve bellek bozulmaları gibi hataları Rust derleyicisi henüz derleme aşamasında engelleyerek güvenli bir ortam sağlar.

---

🧵 1. Thread Kullanımı (`thread::spawn` ve `join`) ⚙️

İşletim sistemi seviyesinde eşzamanlı kod çalıştırmak için `std:🧵:spawn` fonksiyonunu kullanırız.

use std::thread;
use std::time:uration;

fn main() {
let handle = thread::spawn(|| {
for i in 1..5 {
println!("İkinci Thread (Spawned): {}", i);
thread::sleep(Duration::from_millis(1));
}
});

for i in 1..3 {
println!("Ana Thread (Main): {}", i);
thread::sleep(Duration::from_millis(1));
}

// handle.join() çağrılmazsa Ana Thread bittiğinde spawn edilen Thread yarıda kesilebilir!
handle.join().unwrap(); // Spawn edilen thread'in bitmesini bekler
}

---

📦 2. Thread'ler Arasında Veri Taşımak: `move` Closures 🚚

Bir Thread içinde dışarıdaki bir değişkeni kullanmak istediğimizde, Ownership (Sahiplik) kuralları gereği veriyi Thread içine **move** etmemiz gerekir.

use std::thread;

fn main() {
let v = vec![1, 2, 3];

// 'move' kelimesi 'v' değişkeninin sahipliğini thread içine taşır
let handle = thread::spawn(move || {
println!("Vektör Thread içinde: {:?}", v);
});

handle.join().unwrap();
// println!("{:?}", v); // HATA! 'v' ana thread'de artık geçersizdir.
}

---

📡 3. Kanallar İle Mesaj Gönderimi (Message Passing - `mpsc`) ✉️

Rust, Go dilindekine benzer şekilde "Belleği paylaşarak iletişim kurma; iletişim kurarak belleği paylaş" felsefesini benimser.

Bunun için **`mpsc` (Multiple Producer, Single Consumer - Çoklu Üretici, Tek Tüketici)** kanalları kullanılır.

use std::sync::mpsc;
use std::thread;

fn main() {
// tx: Transmitter (Gönderici), rx: Receiver (Alıcı)
let (tx, rx) = mpsc::channel();

thread::spawn(move || {
let mesaj = String::from("Selam Ana Thread!");
tx.send(mesaj).unwrap(); // 'mesaj' sahipliği kanala devredildi!
// println!("{}", mesaj); // HATA! Sahiplik gönderildiği için kullanılamaz.
});

let alinan = rx.recv().unwrap(); // Mesaj gelene kadar ana thread'i bloklar
println!("Gelen Mesaj: {}", alinan);
}

### Çoklu Gönderici (Multiple Producers):
`tx.clone()` yöntemiyle birden fazla gönderici oluşturup aynı kanala veri basabiliriz:

use std::sync::mpsc;
use std::thread;

fn main() {
let (tx, rx) = mpsc::channel();

let tx1 = tx.clone(); // İkinci göndericiyi klonladık
thread::spawn(move || {
tx1.send(String::from("Thread 1'den mesaj")).unwrap();
});

thread::spawn(move || {
tx.send(String::from("Thread 2'den mesaj")).unwrap();
});

for gelen in rx {
println!("Alındı: {}", gelen);
}
}

---

🔒 4. Paylaşılan Durumlu Eşzamanlılık: `Mutex<T>` ve `Arc<T>` 🤝

Kanallar (Message Passing) verinin sahipliğini bir yerden diğerine aktarır. Ancak bazen birden fazla Thread'in **aynı bellek alanına** erişip veriyi değiştirmesi gerekir.

### A. `Mutex<T>` (Mutual Exclusion)
`Mutex<T>`, aynı anda yalnızca **TEK BİR Thread'in** veriye erişmesine izin veren bir kilit mekanizmasıdır. Veriye erişmek için öncelikle kilidi (`lock()`) almak gerekir.

### B. `Arc<T>` (Atomically Reference Counted)
Bölüm 15'te gördüğümüz `Rc<T>` tek thread için geçerliydi. Thread'ler arasında güvenle referans sayacı tutabilmek için **`Arc<T>`** (Atomic Rc) kullanılır.

`Arc<Mutex<T>>` kombinasyonu, Thread'ler arası paylaşımlı ve değiştirilebilir veri yönetiminin standart yoludur.

use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
// Mutex'i Arc içine sararak Thread-safe kıldık
let sayac = Arc::new(Mutex::new(0));
let mut handles = vec![];

for _ in 0..10 {
let sayac_clone = Arc::clone(&sayac);
let handle = thread::spawn(move || {
// .lock() ile verinin kilidini alıyoruz.
// MutexGuard scope dışına çıktığında kilit OTOMATİK serbest bırakılır!
let mut num = sayac_clone.lock().unwrap();
*num += 1;
});
handles.push(handle);
}

for handle in handles {
handle.join().unwrap();
}

println!("Sonuç Sayacı: {}", *sayac.lock().unwrap()); // 10
}

---

🧬 5. Extensible Concurrency: `Send` ve `Sync` Trait'leri 🛡️

Rust dilinin çekirdeğinde Thread yönetimi ile ilgili neredeyse hiçbir şey yoktur. Eşzamanlılık özellikleri standart kütüphane ve `Send` / `Sync` adı verilen iki özel Trait üzerine kuruludur:

• **`Send`:** Bir tipin sahipliğinin (ownership) başka bir Thread'e aktarılabileceğini belirtir. (`Rc<T>` Send DEĞİLDİR!).
• **`Sync`:** Bir tipe birden fazla Thread'in referanslar aracılığıyla erişebileceğini belirtir (`T` Sync ise `&T` Send'dir).

> **Not:** `Send` ve `Sync` özel Trait'lerdir (Marker Traits). Neredeyse tüm temel Rust tipleri otomatik olarak bu Trait'lere sahiptir. Kendi oluşturduğunuz Struct'ın tüm alanları `Send`/`Sync` ise, sizin Struct'ınız da otomatik olarak `Send`/`Sync` olur!

---

📝 Bölüm Özeti ve Gelecek Bölüm 🔮

Bu bölümde Thread oluşturmayı, `mpsc` kanalları ile mesajlaşmayı, `Arc<Mutex<T>>` yapısıyla thread-safe ortak bellek yönetimini ve `Send`/`Sync` mantığını öğrendik.

👉 Bölüm 17'de Bizi Ne Bekliyor?
• Modern Rust'ın Olmazsa Olmazı: **Async / Await ve Asenkron Programlama** 🚀
• Futures ve Polling mantığı
• **Tokio Runtim
e** ile asenkron ağ ve I/O işlemleri
• `async fn`, `.await` ve `tokio::spawn`

Sorularınızı konu altından iletebilirsiniz. Bir sonraki bölümde görüşmek üzere! 🦀✨

🔒 Bu içeriği görmek için giriş yapın

Giriş Yap Forum Kayıt Ol Telegram Grubumuza Katıl