Existe alguma forma de resolver o problema de…

Sim, isso existe. As abordagens principais:

Sincronização (Synchronization): Uso da palavra-chave synchronized para métodos ou blocos de código, garantindo que apenas um thread possa executar esse código de cada vez.
Bloqueios (Locks): Uso de classes do pacote java.util.concurrent.locks, como ReentrantLock, que oferecem um controle mais flexível sobre os bloqueios.
Variáveis atômicas (Atomic Variables): Uso de classes do pacote java.util.concurrent.atomic, como AtomicInteger, AtomicLong, que fornecem operações atômicas (ler-modificar-escrever) sem necessidade de bloqueio explícito.
Objetos imutáveis (Immutable Objects): Criação de objetos cujo estado não pode ser alterado após a criação. Se vários threads têm referências ao mesmo objeto imutável, eles não podem modificá-lo, o que evita condições de corrida.
Coleções thread-safe (Thread-Safe Collections): Uso de coleções do pacote java.util.concurrent, como ConcurrentHashMap, CopyOnWriteArrayList, que garantem acesso seguro de múltiplos threads.

Exemplo de uso de synchronized:

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

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

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

Exemplo 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(); // Adquire o bloqueio
        try {
            count++;
        } finally {
            lock.unlock(); // Liberta o bloqueio
        }
    }

    public int getCount() {
        lock.lock(); // Adquire o bloqueio
        try {
            return count;
        } finally {
            lock.unlock(); // Liberta o bloqueio
        }
    }
}

Exemplo 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(); // Leitura atômica
    }
}

A escolha de um método específico depende da natureza da tarefa e do nível de desempenho necessário. A sincronização é simples de usar, mas pode gerar custos adicionais. Os bloqueios oferecem maior flexibilidade. As variáveis atômicas costumam ser mais eficientes para operações simples. O uso de objetos imutáveis e coleções thread-safe também é uma forma eficaz de evitar condições de corrida.

Existe alguma forma de resolver o problema de condição de corrida?