¿Qué métodos existen para luchar contra las…

Una colisión, o conflicto, ocurre durante la fusión de cambios de diferentes ramas o cuando varios procesos/hilos modifican los mismos datos.

Los métodos para manejar colisiones dependen de su naturaleza:

Gestión de versiones (por ejemplo, Git):
- Resolución manual: Git marca las áreas conflictivas del código. El desarrollador edita manualmente los archivos, eligiendo los cambios necesarios.
- Uso de herramientas de fusión: Las herramientas visuales ayudan a comparar y combinar cambios línea por línea.
- Rebase: Mover commits de una rama a otra para crear una historia más lineal. Puede requerir resolver conflictos secuencialmente para cada commit.
- Estrategias de fusión (Merge Strategies): Git ofrece varias estrategias (recursive, ours, theirs) para resolver automáticamente (o semi-automáticamente) ciertos tipos de conflictos.
- Fusiones/Rebases frecuentes: Reducen la probabilidad de conflictos complejos.
```
// Ejemplo de código en conflicto en Git que debe resolverse manualmente
func updateData() {
    // Lógica de actualización de datos
<<<<<<< HEAD
    let newValue = "Valor de la RamaA"
=======
    let newValue = "Valor de la RamaB"
>>>>>>> feature/branchB
    print("Actualizando con: \(newValue)")
}
```

En multihilo/multiproceso (acceso concurrente a recursos):

Bloqueos (Locks/Mutexes): Permiten que solo un hilo tenga acceso exclusivo a la sección crítica del código en cualquier momento.

import Foundation

let mutex = NSLock() // Creación de un mutex

func performOperation() {
    mutex.lock() // Adquisición del bloqueo
    // Sección crítica: código que puede causar colisión en acceso paralelo
    print("Realizando operación segura para hilos")
    mutex.unlock() // Liberación del bloqueo
}

Semánticas de atomicidad: Operaciones que se garantizan se ejecutan completamente o no se ejecutan en absoluto, sin interrupciones de otros hilos.

Uso de colas (Queues, por ejemplo, GCD): Ejecutar tareas en colas secuenciales garantiza que el acceso a recursos compartidos ocurra en un solo hilo.

import Foundation

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

func updateSharedData() {
    serialQueue.async {
        // Acceso a datos compartidos solo desde esta cola
        print("Actualizando datos compartidos de forma asíncrona")
    }
}

Uso de colas concurrentes con barreras (Concurrent Queues with Barriers): Permiten que múltiples hilos realicen operaciones de lectura en paralelo, pero bloquean para operaciones de escritura.

import Foundation

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

func addValue(_ value: Int) {
    concurrentQueue.async(flags: .barrier) {
        // Operación de escritura - se realiza de forma exclusiva
        sharedArray.append(value)
        print("Añadido \(value)")
    }
}

func readArray() {
    concurrentQueue.async {
        // Operación de lectura - puede realizarse en paralelo
        print("Array actual: \(sharedArray)")
    }
}

Operaciones atómicas: Operaciones de bajo nivel que garantizan atomicidad (por ejemplo, usando funciones OSAtomic* o atomics de C++11).
Memoria transaccional (Software Transactional Memory - STM): Enfoque de alto nivel que permite agrupar una serie de operaciones en una transacción que debe tener éxito en su totalidad o revertirse completamente.

La elección del método depende del contexto y del tipo de colisión.

¿Qué métodos existen para luchar contra las colisiones?