¿Qué métodos de lucha contra la carrera de hilos…

Existen varios enfoques principales para la sincronización de hilos y la prevención de condiciones de carrera en Android, además de volatile.

Uso de synchronized: Bloquea el acceso al código o método para otros hilos hasta que el hilo actual termine.

// Método sincronizado
synchronized void incrementCounter() {
    counter++;
}

// Bloque sincronizado
void updateData() {
    synchronized (this) { // u otro objeto monitor
        // código que requiere sincronización
    }
}

Uso de clases del paquete java.util.concurrent.locks: Ofrecen mecanismos de bloqueo más flexibles que synchronized.

import java.util.concurrent.locks.ReentrantLock;

private final ReentrantLock lock = new ReentrantLock();

void performLockedOperation() {
    lock.lock(); // Adquisición del bloqueo
    try {
        // Código protegido por el bloqueo
    } finally {
        lock.unlock(); // Liberación del bloqueo (importante en finally)
    }
}

Uso de clases del paquete java.util.concurrent.atomic: Proporcionan operaciones atómicas que se ejecutan como una sola unidad sin interrupciones por otros hilos. Adecuadas para operaciones simples sobre tipos primitivos y referencias.
```
import java.util.concurrent.atomic.AtomicInteger;

private final AtomicInteger atomicCounter = new AtomicInteger(0);

void incrementAtomicCounter() {
    atomicCounter.incrementAndGet(); // Incremento atómico
}
```

Uso de colecciones seguras para hilos: Colecciones del paquete java.util.concurrent (por ejemplo, ConcurrentHashMap, CopyOnWriteArrayList) diseñadas para uso seguro en entornos multihilo sin sincronización explícita por parte del desarrollador.

import java.util.concurrent.ConcurrentHashMap;
import java.util.Map;

private final Map<String, Integer> concurrentMap = new ConcurrentHashMap<>();

void updateMap(String key, Integer value) {
    concurrentMap.put(key, value); // operación segura de escritura
}

**Uso de **ThreadLocal**: Permite crear una variable que tendrá una copia separada para cada hilo. De este modo, cada hilo trabaja con su propia copia de datos, evitando la carrera.

private final ThreadLocal<Integer> threadLocalValue = new ThreadLocal<Integer>() {
    @Override
    protected Integer initialValue() {
        return 0; // Valor inicial para cada hilo
    }
};

void processData() {
    int value = threadLocalValue.get();
    value++;
    threadLocalValue.set(value); // Establecer valor para el hilo actual
}

La elección del método depende de la naturaleza de la tarea, la necesidad de bloqueo, el tipo de datos y el rendimiento requerido.

¿Qué métodos de lucha contra la carrera de hilos, además del uso de la palabra clave volatile, conoces?