Concurrency: threads, mutex ve arc ile Güvenli Paralellik

[irfo]

Rust, "korkusuz paralellik" (fearless concurrency) sloganıyla bilinir. Bellek güvenliği ve sahiplik kuralları sayesinde, diğer dillerde çalışma zamanında (runtime) kabusa dönüşen veri yarışlarını (data races) Rust derleme anında tespit eder.
Güvenli paralelliğin üç sac ayağı şunlardır: threads (iş parçacıkları), Arc (paylaşımlı sahiplik) ve Mutex (karşılıklı dışlama).

---

1. Threads: İş Parçacıkları Oluşturma​

Rust, işletim sistemi düzeyinde (1:1) thread yapısını kullanır. thread::spawn ile yeni bir iş parçacığı başlatılır.
Rust

use std::thread;
use std::time::Duration;

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

    handle.join().unwrap(); // Ana thread'in beklemesini sağlar
}

Not: move anahtar kelimesi, dışarıdaki verilerin sahipliğini thread içine taşımak için sıkça kullanılır.

---

2. Mutex<T>: İçsel Değiştirilebilirlik​

Mutex (Mutual Exclusion), bir veriye aynı anda sadece tek bir thread'in erişmesini sağlar. Veriye erişmek isteyen thread, önce kilidi (lock) almalıdır.

• Kilitleme: .lock() metodu ile yapılır.
• Otomatik Kilit Açma: Kilit (MutexGuard), kapsam (scope) dışına çıktığında otomatik olarak serbest bırakılır (RAII prensibi).

---

3. Arc<T> ve Mutex<T> Kombinasyonu​

Thread'ler arası veri paylaşımında en yaygın kalıp Arc<Mutex<T>> yapısıdır.

• Arc: Birden fazla thread'in veriye sahip olmasını sağlar.
• Mutex: Birden fazla thread'in veriyi güvenli bir şekilde değiştirmesini sağlar.

Rust

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

fn main() {
    // 0 değerine sahip, thread-safe bir sayaç oluşturuyoruz
    let sayac = Arc::new(Mutex::new(0));
    let mut handlelar = vec![];

    for _ in 0..10 {
        let sayac_kopya = Arc::clone(&sayac);
        let handle = thread::spawn(move || {
            let mut num = sayac_kopya.lock().unwrap();
            *num += 1;
        });
        handlelar.push(handle);
    }

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

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

---

4. Send ve Sync Trait'leri​

Rust'ın paralelliği bu kadar güvenli kılan gizli kahramanlar bu iki trait'tir:

• Send: Bir tipin sahipliğinin başka bir thread'e aktarılabileceğini belirtir.
• Sync: Bir tipe birden fazla thread'in referans yoluyla aynı anda erişebileceğini belirtir.

Çoğu temel tip (i32, String vb.) hem Send hem Sync'tir. Ancak Rc<T> bunlardan hiçbirini uygulamaz, bu yüzden thread'ler arasında taşınamaz veya paylaşılamaz.

---

Özet Karşılaştırma​

Kavram	Rolü
spawn	Yeni bir paralel çalışma hattı açar.
Arc	Veriyi kaç thread'in kullandığını sayan atomik bir "akıllı işaretçi".
Mutex	Veriye erişimi sıraya koyan "trafik ışığı".
join	Ana programın diğer thread'ler bitene kadar beklemesini sağlar.