Какви методи съществуват за борба с колизиите?

Колизията или конфликтът възниква при сливане на промени от различни клонове или при взаимодействие на няколко процеса/нишки, които променят едни и същи данни.

Методите за справяне с колизиите зависят от тяхната природа:

Управление на версии (например, Git):
- Ръчно разрешаване: Git маркира конфликтните части от кода. Разработчикът ръчно редактира файловете, избирайки желаните промени.
- Използване на инструменти за сливане: Визуални инструменти помагат за сравняване и обединяване на промени ред по ред.
- Rebasing: Преместване на commit-ове от една клонка върху друга за създаване на по-линейна история. Може да изисква разрешаване на конфликти за всеки commit.
- Стратегии за сливане (Merge Strategies): Git предлага различни стратегии (recursive, ours, theirs) за автоматично или полуавтоматично разрешаване на някои типове конфликти.
- Чести сливания/rebasing: Намаляват вероятността за възникване на сложни конфликти.
```
// Пример за конфликтен код в Git, който трябва да бъде разрешен ръчно
func updateData() {
    // Логика за актуализиране на данни
<<<<<<< HEAD
    let newValue = "Стойност от BranchA"
=======
    let newValue = "Стойност от BranchB"
>>>>>>> feature/branchB
    print("Актуализация с: \(newValue)")
}
```
В многонишкова/многопроцесна среда (конкурентен достъп до ресурси):
- Блокировки (Locks/Mutexes): Позволяват само на един поток да получи ексклузивен достъп до критичната секция на кода по всяко време.
```
import Foundation

let mutex = NSLock() // Създаване на мютекс

func performOperation() {
    mutex.lock() // Засичане на блокировката
    // Критична секция: код, който може да предизвика колизия при паралелен достъп
    print("Изпълнение на потокобезопасна операция")
    mutex.unlock() // Освобождаване на блокировката
}
```
- Атомарни операции: Гарантират, че операциите се изпълняват напълно или изобщо не, без прекъсване от други потоци.
- Опашки (Queues, например GCD): Изпълнението на задачи в последователни опашки гарантира, че достъпът до споделените ресурси става по един поток.
```
import Foundation

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

func updateSharedData() {
    serialQueue.async {
        // Достъп до споделените данни само от тази опашка
        print("Актуализиране на споделените данни асинхронно")
    }
}
```
- Използване на конкурентни опашки с бариери (Concurrent Queues with Barriers): Позволяват на множество потоци да изпълняват операции за четене паралелно, но ги блокират за операции за писане.
```
import Foundation

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

func addValue(_ value: Int) {
    concurrentQueue.async(flags: .barrier) {
        // Операция за писане - изпълнява се изключително
        sharedArray.append(value)
        print("Добавено \(value)")
    }
}

func readArray() {
    concurrentQueue.async {
        // Операция за четене - може да се изпълнява паралелно
        print("Текущ масив: \(sharedArray)")
    }
}
```
- Атомарни операции: Ниско ниво операции, гарантиращи атомарност (например, с използване на OSAtomic* функции или C++11 atomics).
- Транзакционна памет (Software Transactional Memory - STM): Високо ниво, което позволява групиране на серия операции в транзакция, която или се изпълнява успешно, или се връща обратно цялата.

Изборът на метод зависи от контекста и типа на конфликта.