Jakie metody istnieją do walki z kolizjami?

Kolizja, czyli konflikt, występuje podczas łączenia zmian z różnych gałęzi lub podczas interakcji wielu procesów/wątków, które modyfikują te same dane.

Metody radzenia sobie z kolizjami zależą od ich charakteru:

Zarządzanie wersjami (np. Git):
- Ręczne rozwiązywanie: Git oznacza obszary kodu z konfliktem. Programista ręcznie edytuje pliki, wybierając potrzebne zmiany.
- Użycie narzędzi do scalania: Narzędzia wizualne pomagają porównywać i scalać zmiany linia po linii.
- Rebasing: Przenoszenie commitów z jednej gałęzi na inną w celu utworzenia bardziej liniowej historii. Może wymagać rozwiązywania konfliktów kolejno dla każdego commita.
- Strategie scalania: Git oferuje różne strategie (recursive, ours, theirs) do automatycznego (lub półautomatycznego) rozwiązywania niektórych typów konfliktów.
- Częste scalanie/rebasing: Zmniejszają prawdopodobieństwo wystąpienia złożonych konfliktów.
```
// Przykład konfliktowego kodu w Git, który trzeba rozwiązać ręcznie
func updateData() {
    // Logika aktualizacji danych
<<<<<<< HEAD
    let newValue = "Wartość z BranchA"
=======
    let newValue = "Wartość z BranchB"
>>>>>>> feature/branchB
    print("Aktualizacja o: \(newValue)")
}
```

W wielowątkowości/wieloprocesowości (współbieżny dostęp do zasobów):

Blokady (Locks/Mutexes): Pozwalają tylko jednemu wątkowi na wyłączny dostęp do sekcji krytycznej kodu w dowolnym momencie.

import Foundation

let mutex = NSLock() // Tworzenie mutexa

func performOperation() {
    mutex.lock() // Zdobycie blokady
    // Sekcja krytyczna: kod, który może wywołać kolizję przy równoległym dostępie
    print("Wykonywanie bezpiecznej operacji wątkowo")
    mutex.unlock() // Zwolnienie blokady
}

Semantyki atomowości: Operacje, które gwarantują, że są wykonywane w całości lub wcale, bez przerwań przez inne wątki.

Użycie kolejek (Queues, np. GCD): Wykonywanie zadań na kolejach sekwencyjnych gwarantuje, że dostęp do wspólnych zasobów odbywa się przez jeden wątek.

import Foundation

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

func updateSharedData() {
    serialQueue.async {
        // Dostęp do wspólnych danych tylko z tej kolejki
        print("Aktualizacja współdzielonych danych asynchronicznie")
    }
}

Użycie kolejek współbieżnych z barierami: Pozwalają wielu wątkom wykonywać operacje odczytu równolegle, ale blokują je do operacji zapisu.

import Foundation

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

func addValue(_ value: Int) {
    concurrentQueue.async(flags: .barrier) {
        // Operacja zapisu - wykonywana wyłącznie
        sharedArray.append(value)
        print("Dodano \(value)")
    }
}

func readArray() {
    concurrentQueue.async {
        // Operacja odczytu - może być wykonywana równolegle
        print("Aktualna tablica: \(sharedArray)")
    }
}

Operacje atomowe: Operacje niskopoziomowe gwarantujące atomowość (np. z użyciem funkcji OSAtomic* lub atomics z C++11).
Pamięć transakcyjna (Software Transactional Memory - STM): Podejście wysokiego poziomu, pozwalające grupować serię operacji w transakcję, która albo się powiedzie w całości, albo zostanie całkowicie wycofana.

Wybór metody zależy od kontekstu i typu kolizji.