Ce metode există pentru a combate coliziunile?

Coliziunea sau conflictul apare atunci când se combină modificări din ramuri diferite sau când mai multe procese/fire de execuție modifică aceleași date.

Metodele de gestionare a coliziunilor depind de natura lor:

Gestionarea versiunilor (de exemplu, Git):
- Rezolvare manuală: Git marchează secțiunile de cod conflictuale. Dezvoltatorul editează manual fișierele, alegând modificările dorite.
- Utilizarea instrumentelor de fuziune: Instrumentele vizuale ajută la compararea și combinarea modificărilor linie cu linie.
- Rebasing: Mutarea commit-urilor dintr-o ramură peste alta pentru a crea o istorie mai liniară. Poate necesita rezolvarea conflictelor pentru fiecare commit în parte.
- Strategii de fuziune (Merge Strategies): Git oferă diferite strategii (recursive, ours, theirs) pentru rezolvarea automată (sau semi-automată) a anumitor tipuri de conflicte.
- Fuziuni/ rebasing frecvent: Reduc riscul apariției conflictelor complexe.
```
// Exemplu de cod conflictual în Git, care trebuie rezolvat manual
func updateData() {
    // Logica de actualizare a datelor
<<<<<<< HEAD
    let newValue = "Valoare din BranchA"
=======
    let newValue = "Valoare din BranchB"
>>>>>>> feature/branchB
    print("Actualizare cu: \(newValue)")
}
```

În multi-threading/multi-procesare (acces concurent la resurse):

Blocări (Locks/Mutexes): Permite unui singur fir de execuție să obțină acces exclusiv la secțiunea critică a codului în orice moment.

import Foundation

let mutex = NSLock() // Crearea unui mutex

func performOperation() {
    mutex.lock() // Capturarea blocării
    // Secțiunea critică: cod care poate cauza coliziune în cazul accesului paralel
    print("Executare operație sigură pentru firul de execuție")
    mutex.unlock() // Eliberarea blocării
}

Semantica atomicității: Operații garantate să fie executate complet sau deloc, fără întrerupere de către alte fire.

Utilizarea cozii (Queues, de exemplu GCD): Executarea sarcinilor pe cozi secvențiale garantează că accesul la resursele comune se face pe un singur fir.

import Foundation

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

func updateSharedData() {
    serialQueue.async {
        // Acces la datele comune doar din această coadă
        print("Actualizare date partajate asincron")
    }
}

Utilizarea cozii concurente cu bariere (Concurrent Queues with Barriers): Permite mai multor fire să execute operații de citire în paralel, dar le blochează pentru operații de scriere.

import Foundation

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

func addValue(_ value: Int) {
    concurrentQueue.async(flags: .barrier) {
        // Operație de scriere - executată exclusiv
        sharedArray.append(value)
        print("Adăugat \(value)")
    }
}

func readArray() {
    concurrentQueue.async {
        // Operație de citire - poate fi executată în paralel
        print("Array curent: \(sharedArray)")
    }
}

Operații atomice: Operații la nivel scăzut, care garantează atomicitatea (de exemplu, utilizând funcțiile OSAtomic* sau C++11 atomics).
Memorie tranzacțională (Software Transactional Memory - STM): Abordare de nivel înalt, care permite gruparea unei serii de operații într-o tranzacție, care fie reușește complet, fie este rollbackată complet.

Alegerea metodei depinde de context și de tipul de coliziune.