¿Existe alguna forma de resolver el problema de la…

Sí, existe. Los enfoques principales:

Sincronización (Synchronization): Uso de palabras clave synchronized para métodos o bloques de código, lo que garantiza que solo un hilo pueda ejecutar ese código en un momento dado.
Bloqueos (Locks): Uso de clases del paquete java.util.concurrent.locks, como ReentrantLock, que ofrecen un control más flexible sobre los bloqueos.
Variables atómicas (Atomic Variables): Uso de clases del paquete java.util.concurrent.atomic, como AtomicInteger, AtomicLong, que proporcionan operaciones atómicas (leer-modificar-escribir) sin necesidad de bloqueo explícito.
Objetos inmutables (Immutable Objects): Creación de objetos cuyo estado no puede cambiarse después de su creación. Si varios hilos tienen referencias al mismo objeto inmutable, no pueden modificarlo, lo que evita condiciones de carrera.
Colecciones seguras para hilos (Thread-Safe Collections): Uso de colecciones del paquete java.util.concurrent, como ConcurrentHashMap, CopyOnWriteArrayList, que garantizan acceso seguro desde múltiples hilos.

Ejemplo de uso de synchronized:

// Ejemplo de método sincronizado
public class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public synchronized int getCount() {
        return count;
    }
}

Ejemplo de uso de ReentrantLock:

import java.util.concurrent.locks.ReentrantLock;

public class AnotherCounter {
    private int count = 0;
    private final ReentrantLock lock = new ReentrantLock();

    public void increment() {
        lock.lock(); // Adquiere el bloqueo
        try {
            count++;
        } finally {
            lock.unlock(); // Libera el bloqueo
        }
    }

    public int getCount() {
        lock.lock(); // Adquiere el bloqueo
        try {
            return count;
        } finally {
            lock.unlock(); // Libera el bloqueo
        }
    }
}

Ejemplo de uso de AtomicInteger:

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicCounter {
    private final AtomicInteger count = new AtomicInteger(0);

    public void increment() {
        count.incrementAndGet(); // Incremento atómico
    }

    public int getCount() {
        return count.get(); // Lectura atómica
    }
}

La elección de un método específico depende de la naturaleza de la tarea y del nivel de rendimiento requerido. La sincronización es sencilla de usar, pero puede generar costos adicionales. Los bloqueos ofrecen mayor flexibilidad. Las variables atómicas suelen ser más eficientes para operaciones simples. El uso de objetos inmutables y colecciones seguras para hilos también es una forma efectiva de evitar condiciones de carrera.

¿Existe alguna forma de resolver el problema de la condición de carrera?