Millised meetodid on olemas kokkupõrgete vastu…

Kolissioon, või konflikt, tekib, kui erinevatest harudest tehtud muudatused liidetakse või kui mitu protsessi/niiti muudavad samaaegselt samu andmeid:

Kolissioonide vastu võitlemise meetodid sõltuvad nende olemusest:

Versioonide haldamine (näiteks Git):
- Käsitsi lahendamine: Git märgib konfliktseid koodiosi. Arendaja redigeerib käsitsi faile, valides vajalikud muudatused:
- Liitmismootorite kasutamine: Visuaalsed tööriistad aitavad võrrelda ja ühendada muudatusi rida-ridade kaupa:
- Rebasing (ülesehitamine): Komiitide teisaldamine ühest harust teise, et luua lineaarsem ajalugu. Võib nõuda konfliktide lahendamist iga komiidi puhul:
- Liitmismeetodid (Merge Strategies): Git pakub erinevaid strateegiaid (recursive, ours, theirs) automaatseks või poolautomaatseks konfliktide lahendamiseks:
- Korduvad liitmised/rebasingud: Vähendavad keeruliste konfliktide tekkimise tõenäosust:
```
// Konfliktse koodi näide Gitis, mida tuleb käsitsi lahendada
func updateData() {
    // Andmete uuendamise loogika
<<<<<<< HEAD
    let newValue = "Value from BranchA"
=======
    let newValue = "Value from BranchB"
>>>>>>> feature/branchB
    print("Updating with: \(newValue)")
}
```

Mitme niidi/multiprotsessilise keskkonna puhul (konkurentsivõimeline juurdepääs ressurssidele):

Lukud (Locks/Mutexes): võimaldavad ainult ühel niidil saada eksklusiivset juurdepääsu kriitilisele sektsioonile igal ajal:

import Foundation

let mutex = NSLock() // Lukku loomine

func performOperation() {
    mutex.lock() // Lukku haaramine
    // Kriitiline sektsioon: kood, mis võib põhjustada konflikti paralleelse juurdepääsu korral
    print("Performing thread-safe operation")
    mutex.unlock() // Lukust vabastamine
}

Atomaarsed operatsioonid: operatsioonid, mis garanteerivad, et need täidetakse täielikult või mitte üldse, ilma teiste niitide sekkumiseta:

Jadade kasutamine (Queues, näiteks GCD): ülesannete täitmine järjestikustes järjekordades tagab, et juurdepääs ühistele ressurssidele toimub ühe niidiga:

import Foundation

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

func updateSharedData() {
    serialQueue.async {
        // Juurdepääs ühistele andmetele ainult sellest järjekorrast
        print("Updating shared data asynchronously")
    }
}

Konkurentsete järjekordade kasutamine barjääridega (Concurrent Queues with Barriers): võimaldab mitmel niidil paralleelselt lugeda, kuid blokeerib neid kirjutamise ajal:

import Foundation

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

func addValue(_ value: Int) {
    concurrentQueue.async(flags: .barrier) {
        // Kirjutamise operatsioon - täidetakse eksklusiivselt
        sharedArray.append(value)
        print("Added \(value)")
    }
}

func readArray() {
    concurrentQueue.async {
        // Lugemise operatsioon - võib toimuda paralleelselt
        print("Current array: \(sharedArray)")
    }
}

Atomaarsed operatsioonid: madala taseme operatsioonid, mis garanteerivad atomaarsuse (näiteks kasutades OSAtomic* funktsioone või C++11 atomics):
Tõrkelevad mälud (Software Transactional Memory - STM): kõrgetasemeline lähenemine, mis võimaldab grupeerida mitmeid operatsioone transaktsiooniks, mis kas õnnestub täielikult või tühistatakse:

Valik sõltub kontekstist ja koliziooni tüübist.

Millised meetodid on olemas kokkupõrgete vastu võitlemiseks?