Jaké metody existují pro boj s kolizemi?

Kolize nebo konflikt nastává při slučování změn z různých větví nebo při současném ovlivňování stejných dat několika procesy/vlákny.

Metody řešení kolizí závisí na jejich povaze:

Správa verzí (například Git):
- Ruční řešení: Git označuje konfliktní části kódu. Vývojář ručně upravuje soubory a vybírá požadované změny.
- Použití nástrojů pro sloučení: Vizualizační nástroje pomáhají porovnávat a slučovat změny řádek po řádku.
- Rebase: Přesun commitů z jedné větve na druhou za účelem vytvoření lineárnější historie. Může vyžadovat řešení konfliktů pro každý commit.
- Strategie slučování (Merge Strategies): Git nabízí různé strategie (recursive, ours, theirs) pro automatické nebo poloautomatické řešení některých typů konfliktů.
- Časté slučování/rebase: Snižují pravděpodobnost vzniku složitých konfliktů.
```
// Příklad konfliktu v kódu v Git, který je třeba ručně vyřešit
func updateData() {
    // Logika aktualizace dat
<<<<<<< HEAD
    let newValue = "Hodnota z větve BranchA"
=======
    let newValue = "Hodnota z větve BranchB"
>>>>>>> feature/branchB
    print("Aktualizace s: \(newValue)")
}
```

V prostředí s více vlákny/multiprocesové (současný přístup ke zdrojům):

Zámky (Locks/Mutexes): Umožňují pouze jednomu vláknu získat exkluzivní přístup ke kritické sekci kódu v libovolném okamžiku.

import Foundation

let mutex = NSLock() // Vytvoření mutexu

func performOperation() {
    mutex.lock() // Získání zámku
    // Kritická sekce: kód, který může způsobit kolizi při paralelním přístupu
    print("Provádění bezpečné operace")
    mutex.unlock() // Uvolnění zámku
}

Atomické operace: Zaručují, že operace jsou provedeny úplně nebo vůbec, bez přerušení jinými vlákny.

Fronty (Queues, například GCD): Vykonávání úloh na sekvenčních frontách zajišťuje, že přístup ke sdíleným zdrojům probíhá po jednom vlákně.

import Foundation

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

func updateSharedData() {
    serialQueue.async {
        // Přístup ke sdíleným datům pouze z této fronty
        print("Asynchronní aktualizace sdílených dat")
    }
}

Použití konkurenčních front s bariérami (Concurrent Queues with Barriers): Umožňují více vláknům provádět operace čtení paralelně, ale blokují je pro zápisové operace.

import Foundation

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

func addValue(_ value: Int) {
    concurrentQueue.async(flags: .barrier) {
        // Zápisová operace - provádí se výhradně
        sharedArray.append(value)
        print("Přidáno \(value)")
    }
}

func readArray() {
    concurrentQueue.async {
        // Čtecí operace - může být provedena paralelně
        print("Aktuální pole: \(sharedArray)")
    }
}

Atomické operace: Nízké úrovně operací, které zaručují atomicitu (například s použitím funkcí OSAtomic* nebo C++11 atomics).
Transakční paměť (Software Transactional Memory - STM): Vyšší úroveň přístupu, která umožňuje seskupit sérii operací do transakce, která buď proběhne úspěšně, nebo je úplně vrácena zpět.

Volba metody závisí na kontextu a typu kolize.