Çarpışmalarla mücadele etmek için hangi yöntemler…

Farklı dallardan yapılan değişikliklerin birleştirilmesi sırasında veya birden fazla süreç/iş parçacığının aynı verileri değiştirmesiyle bir çakışma veya çatışma oluşur.

Çakışmaların nasıl ele alınacağı, doğalarına bağlıdır:

Sürüm kontrolü (örneğin, Git):
- Manuel çözüm: Git, çatışan kod bölümlerini işaretler. Geliştirici, gerekli değişiklikleri seçerek dosyaları manuel olarak düzenler.
- Birleştirme araçlarının kullanımı: Görsel araçlar, satır satır karşılaştırma ve birleştirmeye yardımcı olur.
- Rebase: Bir dalın commitlerini başka bir dal üzerine taşıyarak daha doğrusal bir tarih oluşturur. Her commit için çatışmaları sıralı olarak çözmeyi gerektirebilir.
- Birleştirme stratejileri: Git, otomatik (veya yarı otomatik) olarak belirli çatışma türlerini çözmek için çeşitli stratejiler (recursive, ours, theirs) sunar.
- Sık sık birleştirme/rebase işlemleri: Karmaşık çatışma olasılığını azaltır.
```
// Çözülmesi gereken çatışmalı Git kod örneği
func updateData() {
    // Veri güncelleme mantığı
<<<<<<< HEAD
    let newValue = "BranchA'dan Değer"
=======
    let newValue = "BranchB'den Değer"
>>>>>>> feature/branchB
    print("Güncelleme ile: \(newValue)")
}
```

Çok iş parçacıklı/çok süreçli ortamda (kaynaklara eşzamanlı erişim):

Kilitlemeler (Locks/Mutexes): Aynı anda sadece bir iş parçacığının kritik bölgeye erişmesine izin verir.

import Foundation

let mutex = NSLock() // Mutex oluşturma

func performOperation() {
    mutex.lock() // Kilidi edin
    // Kritik bölüm: paralel erişimde çatışmaya neden olabilecek kod
    print("İş parçacığı güvenli işlem yapıyor")
    mutex.unlock() // Kilidi serbest bırak
}

Atomiklik semantikası: İşlemler, tamamen yürütüleceği veya hiç yürütülmeyeceği garantisiyle, diğer iş parçacıklarının kesintisi olmadan.

Kuyrukların kullanımı (Queues, örneğin GCD): Görevleri sıralı kuyruklarda yürütmek, kaynaklara erişimin tek bir iş parçacığı tarafından yapılmasını sağlar.

import Foundation

let serialQueue = DispatchQueue(label: "com.example.mySerialQueue")

func updateSharedData() {
    serialQueue.async {
        // Paylaşılan verilere sadece bu kuyruktan erişim
        print("Paylaşılan veriyi asenkron güncelliyor")
    }
}

Eş zamanlı kuyruklar ve bariyerler kullanmak (Concurrent Queues with Barriers): Birden fazla iş parçacığının okuma işlemlerini paralel yapmasına izin verir, ancak yazma işlemleri için engeller.

import Foundation

let concurrentQueue = DispatchQueue(label: "com.example.myConcurrentQueue", attributes: .concurrent)
var sharedArray = [Int]()

func addValue(_ value: Int) {
    concurrentQueue.async(flags: .barrier) {
        // Yazma işlemi - özel olarak yapılır
        sharedArray.append(value)
        print("Eklendi \(value)")
    }
}

func readArray() {
    concurrentQueue.async {
        // Okuma işlemi - paralel yapılabilir
        print("Mevcut dizi: \(sharedArray)")
    }
}

Atomik işlemler: OSAtomic* fonksiyonları veya C++11 atomics kullanılarak gerçekleştirilen düşük seviyeli işlemler, atomiklik garantisi sağlar.
Yazılım İşlemsel Bellek (Software Transactional Memory - STM): Bir dizi işlemi bir işlemde gruplandırmaya izin veren yüksek seviyeli yaklaşım, ya tamamen başarılı olur ya da tamamen geri alınır.

Yöntem seçimi, bağlama ve çatışma türüne bağlıdır.

Çarpışmalarla mücadele etmek için hangi yöntemler vardır?