Welke methoden bestaan er om botsingen te bestrijden…

Een botsing, of conflict, ontstaat bij het samenvoegen van wijzigingen uit verschillende takken of bij de interactie van meerdere processen/threads die dezelfde gegevens wijzigen.

De methoden om botsingen te behandelen hangen af van hun aard:

Versiebeheer (bijvoorbeeld Git):
- Handmatige oplossing: Git markeert de conflicterende code-onderdelen. De ontwikkelaar bewerkt de bestanden handmatig en kiest de benodigde wijzigingen.
- Gebruik van merge-tools: Visuele hulpmiddelen helpen bij het vergelijken en samenvoegen van wijzigingen regel voor regel.
- Rebasing: Het verplaatsen van commits van de ene tak naar de andere om een meer lineaire geschiedenis te creëren. Kan vereisen dat conflicten sequentieel voor elke commit worden opgelost.
- Merge-strategieën: Git biedt verschillende strategieën (recursive, ours, theirs) voor automatische (of semi-automatische) oplossing van bepaalde conflicttypen.
- Frequent samenvoegen/rebasing: Vermindert de kans op complexe conflicten.
```
// Voorbeeld van conflicterende code in Git die handmatig moet worden opgelost
func updateData() {
    // Logica voor gegevensupdate
<<<<<<< HEAD
    let newValue = "Waarde van BranchA"
=======
    let newValue = "Waarde van BranchB"
>>>>>>> feature/branchB
    print("Bijwerken met: \(newValue)")
}
```

In multithreading/multiprocessing (gelijktijdige toegang tot bronnen):

Locks/Mutexes: Stellen slechts één thread in staat om exclusieve toegang te krijgen tot het kritieke gedeelte van de code op elk moment.

import Foundation

let mutex = NSLock() // Aanmaken van een mutex

func performOperation() {
    mutex.lock() // Vergrendeling verkrijgen
    // Kritieke sectie: code die conflicten kan veroorzaken bij gelijktijdige toegang
    print("Thread-veilige operatie uitvoeren")
    mutex.unlock() // Vergrendeling vrijmaken
}

Semantiek van atomariteit: Operaties die gegarandeerd volledig worden uitgevoerd of helemaal niet, zonder onderbrekingen door andere threads.

Gebruik van wachtrijen (Queues, bijvoorbeeld GCD): Taken uitvoeren op sequentiële wachtrijen garandeert dat toegang tot gedeelde bronnen door slechts één thread gebeurt.

import Foundation

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

func updateSharedData() {
    serialQueue.async {
        // Toegang tot gedeelde gegevens alleen vanuit deze wachtrij
        print("Gedeelde gegevens asynchroon bijwerken")
    }
}

Gebruik van gelijktijdige wachtrijen met barrières: Stellen meerdere threads in staat om leesbewerkingen parallel uit te voeren, maar blokkeren voor schrijfbewerkingen.

import Foundation

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

func addValue(_ value: Int) {
    concurrentQueue.async(flags: .barrier) {
        // Schrijfbewerking - wordt exclusief uitgevoerd
        sharedArray.append(value)
        print("Toegevoegd \(value)")
    }
}

func readArray() {
    concurrentQueue.async {
        // Leesbewerking - kan parallel worden uitgevoerd
        print("Huidige array: \(sharedArray)")
    }
}

Atomische operaties: Laag-niveau operaties die atomariteit garanderen (bijvoorbeeld met OSAtomic* functies of C++11 atomics).
Transactiek geheugen (Software Transactional Memory - STM): Een hoog-niveau aanpak die het mogelijk maakt om een reeks operaties in een transactie te groeperen, die of volledig slaagt of volledig wordt teruggedraaid.

De keuze van de methode hangt af van de context en het type botsing.

Welke methoden bestaan er om botsingen te bestrijden?