Aké metódy existujú na boj s kolíziami?

Kolízia alebo konflikt nastáva pri zlúčení zmien z rôznych vetiev alebo pri súčasnom ovplyvňovaní rovnakých údajov viacerými procesmi/vláknaami.

Metódy riešenia kolízií závisia od ich povahy:

1. Správa verzií (napríklad Git):

   • Ručné riešenie: Git označuje konfliktné časti kódu. Vývojár ručne upravuje súbory, vyberajúc požadované zmeny.
   • Použitie nástrojov na zlúčenie: Vizuálne nástroje pomáhajú pri porovnávaní a zlúčení zmien riadok po riadku.
   • Rebasing: Presun commitov z jednej vetvy na druhú za účelom vytvorenia lineárnejšej histórie. Môže vyžadovať riešenie konfliktov pre každý commit.
   • Stratégie zlúčenia (Merge Strategies): Git ponúka rôzne stratégie (recursive, ours, theirs) na automatické alebo poloviautomatické riešenie určitých typov konfliktov.
   • Časté zlúčenia/rebasing: Znižujú pravdepodobnosť vzniku zložitých konfliktov.

   // Príklad konfliktu v kóde v Git, ktorý je potrebné ručne vyriešiť
   func updateData() {
       // Logika aktualizácie dát
   <<<<<<< HEAD
       let newValue = "Hodnota z vetvy BranchA"
   =======
       let newValue = "Hodnota z vetvy BranchB"
   >>>>>>> feature/branchB
       print("Aktualizácia s: \(newValue)")
   }
   

2. V prostredí s viacerými vláknami/multiprocesové (konkurentný prístup k zdrojom):

   • Zámky (Locks/Mutexes): Umožňujú len jednému vláknu získať exkluzívny prístup ku kritickej sekcii kódu v akomkoľvek momente.

     import Foundation
     
     let mutex = NSLock() // Vytvorenie mutexu
     
     func performOperation() {
         mutex.lock() // Zabezpečenie zámku
         // Kritická sekcia: kód, ktorý môže spôsobiť kolíziu pri paralelnom prístupe
         print("Vykonávanie bezpečnej operácie")
         mutex.unlock() // Uvoľnenie zámku
     }
     

   • Atómové operácie: Zaručujú, že operácie sú vykonané úplne alebo vôbec, bez prerušovania inými vláknami.
   • Fronty (Queues, napríklad GCD): Vykonávanie úloh na sekvenčných frontoch zabezpečuje, že prístup ku spoločným zdrojom prebieha po jednom vlákne.

     import Foundation
     
     let serialQueue = DispatchQueue(label: "com.example.mySerialQueue")
     
     func updateSharedData() {
         serialQueue.async {
             // Prístup ku spoločným dátam iba z tejto fronty
             print("Aktualizácia spoločných dát asynchrónne")
         }
     }
     

   • Použitie konkurentných front s bariérami (Concurrent Queues with Barriers): Umožňujú viacerým vláknam vykonávať operácie čítania paralelne, ale blokujú ich pre operácie zápisu.

     import Foundation
     
     let concurrentQueue = DispatchQueue(label: "com.example.myConcurrentQueue", attributes: .concurrent)
     var sharedArray = [Int]()
     
     func addValue(_ value: Int) {
         concurrentQueue.async(flags: .barrier) {
             // Operácia zápisu - vykonáva sa výhradne
             sharedArray.append(value)
             print("Pridané \(value)")
         }
     }
     
     func readArray() {
         concurrentQueue.async {
             // Operácia čítania - môže byť vykonávaná paralelne
             print("Aktuálny array: \(sharedArray)")
         }
     }
     

   • Atómové operácie: Nízkoúrovňové operácie, ktoré garantujú atomickosť (napríklad s použitím OSAtomic* funkcií alebo C++11 atomics).
   • Transakčná pamäť (Software Transactional Memory - STM): Vysoká úroveň, ktorá umožňuje skupinovanie série operácií do transakcie, ktorá buď úspešne prebehne, alebo sa úplne vráti späť.

Výber metódy závisí od kontextu a typu kolízie.