Kādas metodes ir pieejamas sadursmju novēršanai?

Kolizija, vai konflikts, rodas, kad mainās dati no dažādām zarēm vai kad vairāki procesi/šūti vienlaikus maina tos pašas datus:

Cīņa ar kolīzijām metodes ir atkarīgas no to rakstura:

Versiju pārvaldība (piemēram, Git):
- Rokas risinājums: Git atzīmē konfliktējošās koda daļas. Izstrādātājs manuāli rediģē failus, izvēloties nepieciešamās izmaiņas:
- Sajaukšanas rīku izmantošana: Vizuālie rīki palīdz salīdzināt un apvienot izmaiņas rindas pēc rindas:
- Rebasing (pārlikšana): Komītu pārvietošana no vienas zaras uz otru, lai izveidotu lineārāku vēsturi. Var būt nepieciešams risināt konfliktus katrā komitā:
- Sajaukšanas stratēģijas: Git piedāvā dažādas stratēģijas (recursive, ours, theirs) automātiskai vai pusautomātiskai dažādu konfliktu risināšanai:
- Bieži sajaukumi/rebasing: Samazina sarežģītu konfliktu rašanās iespējamību:
```
// Konfliktējošā koda piemērs Git, kas jārisina manuāli
func updateData() {
    // Datu atjaunošanas loģika
<<<<<<< HEAD
    let newValue = "Value from BranchA"
=======
    let newValue = "Value from BranchB"
>>>>>>> feature/branchB
    print("Updating with: \(newValue)")
}
```

Daudzšūnu/multiprocesu vidē (konkurētēja piekļuve resursiem):

Bloķētāji (Locks/Mutexes): ļauj tikai vienam šūnam iegūt ekskluzīvu piekļuvi kritiskajai sekcijai jebkurā laikā:

import Foundation

let mutex = NSLock() // Mutesa izveide

func performOperation() {
    mutex.lock() // Bloķēšanas iegūšana
    // Kritiskā sekcija: kods, kas var izraisīt kolīziju paralēlas piekļuves laikā
    print("Performing thread-safe operation")
    mutex.unlock() // Bloķēšanas atbrīvošana
}

Atomu operāciju semantika: operācijas, kas garantē, ka tās tiks pilnībā izpildītas vai vispār netiks, bez citu šūnu iejaukšanās:

Rindu izmantošana (Queues, piemēram, GCD): uzdevumu izpilde secīgās rindās garantē, ka piekļuve kopīgiem resursiem notiek pa vienam šūnam:

import Foundation

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

func updateSharedData() {
    serialQueue.async {
        // Piekļuve kopīgiem datiem tikai no šīs rindas
        print("Updating shared data asynchronously")
    }
}

Konkurējošo rindu izmantošana ar barjerām (Concurrent Queues with Barriers): ļauj vairākiem šūniem vienlaikus veikt lasīšanas operācijas, bet bloķē tos rakstīšanas operācijām:

import Foundation

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

func addValue(_ value: Int) {
    concurrentQueue.async(flags: .barrier) {
        // Rakstīšanas operācija - tiek veikta ekskluzīvi
        sharedArray.append(value)
        print("Added \(value)")
    }
}

func readArray() {
    concurrentQueue.async {
        // Lasīšanas operācija - var tikt veikta paralēli
        print("Current array: \(sharedArray)")
    }
}

Atomāras operācijas: zema līmeņa operācijas, kas garantē atomaritāti (piemēram, ar OSAtomic* funkcijām vai C++11 atomics):
Transakcijas atmiņa (Software Transactional Memory - STM): augstākā līmeņa pieeja, kas ļauj grupēt virkni operāciju transakcijā, kas vai nu pilnībā izpildās, vai vispār ne:

Izvēle ir atkarīga no konteksta un kolizijas veida.