public class Main {

  public static void main(String[] args) {

    final Map<Integer, Integer> map = new HashMap<>();

    Thread thread1 = new Thread(() -> {
      while (true) {
        Integer randomInt = (int) (Math.random() * 10000);
        map.put(randomInt, randomInt);

        try {
          Thread.sleep(20);
        } catch (InterruptedException e) {
          throw new RuntimeException(e);
        }
      }
    });

    Thread thread2 = new Thread(() -> {
      while (true) {
        try {
          List<Integer> randomList = map.values().stream().toList();
        } catch (Exception e) {
          System.out.println("thread2 exception");
          e.printStackTrace();
        }

        try {
          Thread.sleep(40);
        } catch (InterruptedException e) {
          throw new RuntimeException(e);
        }
      }
    });

    thread1.start();
    thread2.start();
  }
}

public class Main {

  public static void main(String[] args) {

    final Map<Integer, Integer> synchronizedMap = Collections.synchronizedMap(new HashMap<>());

    Thread thread1 = new Thread(() -> {
      while (true) {
        Integer randomInt = (int) (Math.random() * 10000);
        synchronizedMap.put(randomInt, randomInt);

        try {
          Thread.sleep(20);
        } catch (InterruptedException e) {
          throw new RuntimeException(e);
        }
      }
    });

    Thread thread2 = new Thread(() -> {
      while (true) {
        try {
          List<Integer> randomList = synchronizedMap.values().stream().toList();
        } catch (Exception e) {
          System.out.println("thread2 exception");
          e.printStackTrace();
        }

        try {
          Thread.sleep(40);
        } catch (InterruptedException e) {
          throw new RuntimeException(e);
        }
      }
    });

    thread1.start();
    thread2.start();
  }
}

public class Main {

  public static void main(String[] args) {

    final ConcurrentMap<Integer, Integer> concurrentMap = new ConcurrentHashMap<>();

    Thread thread1 = new Thread(() -> {
      while (true) {
        Integer randomInt = (int) (Math.random() * 10000);
        concurrentMap.put(randomInt, randomInt);

        try {
          Thread.sleep(20);
        } catch (InterruptedException e) {
          throw new RuntimeException(e);
        }
      }
    });

    Thread thread2 = new Thread(() -> {
      while (true) {
        try {
          List<Integer> randomList = concurrentMap.values().stream().toList();
        } catch (Exception e) {
          System.out.println("thread2 exception");
          e.printStackTrace();
        }

        try {
          Thread.sleep(40);
        } catch (InterruptedException e) {
          throw new RuntimeException(e);
        }
      }
    });

    thread1.start();
    thread2.start();
  }
}

public class Main {

  public static void main(String[] args) {

    final Map<Integer, Integer> map = new HashMap<>();

    Thread thread1 = new Thread(() -> {
      while (true) {
        Integer randomInt = (int) (Math.random() * 10000);
        synchronized (map) {
          map.put(randomInt, randomInt);
        }

        try {
          Thread.sleep(20);
        } catch (InterruptedException e) {
          throw new RuntimeException(e);
        }
      }
    });

    Thread thread2 = new Thread(() -> {
      while (true) {
        try {
          synchronized (map) {
            List<Integer> randomList = map.values().stream().toList();
          }
        } catch (Exception e) {
          System.out.println("thread2 exception");
          e.printStackTrace();
        }

        try {
          Thread.sleep(40);
        } catch (InterruptedException e) {
          throw new RuntimeException(e);
        }
      }
    });

    thread1.start();
    thread2.start();
  }
}

오류가 서버 시작 시 발생하면 계속 발생하고, 처음에 발생하지 않으면 쭉 발생하지 않는 현상은 상태 불일치 또는 경합 조건(race condition) 에 의해 발생하는 전형적인 문제로 보입니다. 이런 문제는 시스템이 초기화될 때 특정한 순서로 작업이 실행될 경우 발생하거나, 특정 상태가 만들어지면 이후로도 계속 문제가 발생할 수 있습니다.

가능한 원인

초기화 시점의 경합 조건:
서버가 시작될 때 여러 스레드가 동시에 HashMap에 접근하여 초기 데이터를 삽입하거나 수정하는 작업을 할 때, 특정 순서로 접근이 이루어지면 HashMap의 상태가 불안정해질 수 있습니다. 예를 들어, 서버 초기화 중 특정 스레드가 HashMap을 변경하고 다른 스레드가 동시에 이 데이터를 사용하려 하면, 데이터 불일치나 상태 불일치가 발생할 수 있습니다.
이 문제는 HashMap의 상태가 초기화 시점에 잘못된 상태로 설정되면 이후에도 계속 그 상태가 유지되기 때문에 발생합니다. 반대로 초기화 시점에 문제없이 설정되면 이후에는 문제가 발생하지 않습니다.

초기 데이터 로드 문제:
서버가 시작될 때, HashMap이 특정 초기 데이터로 채워지거나 외부에서 데이터를 로드할 때 문제가 발생할 수 있습니다. 이 과정에서 HashMap이 여러 스레드에 의해 동시에 수정되면, 이후의 스트림 처리에서도 불일치 상태가 유지됩니다.
만약 초기화 단계에서 이러한 문제가 발생하지 않으면 이후에는 안정적인 상태가 유지될 수 있습니다. 이는 초기화 이후로 HashMap에 대한 접근이 비교적 안정적이기 때문일 수 있습니다.

캐시나 지연된 초기화 문제:
서버 시작 시 HashMap이 특정 서비스나 캐시에 의해 지연 초기화(lazy initialization) 되는 경우, 이 과정에서 동시성이 제대로 처리되지 않으면 문제가 발생할 수 있습니다. 이 경우 초기화가 제대로 되지 않으면 계속 문제가 발생하게 됩니다.

JVM 또는 시스템 환경 문제:
특정 JVM 설정이나 시스템 리소스 상태에 따라 초기화 시점에서만 발생하는 경합 조건이나 리소스 경쟁이 있을 수 있습니다. 이는 서버가 시작될 때 부하가 걸리거나 리소스가 불안정한 상태에서만 문제가 발생하는 것과 유사합니다.

문제 해결 방법

서버 시작 시점 동기화:
서버 초기화 시점에 HashMap을 설정하는 모든 작업을 명시적으로 동기화하여, 한 스레드가 초기화 작업을 독점하도록 설정합니다. 이렇게 하면 초기화 시점의 경합 조건을 방지할 수 있습니다.

스레드 안전한 자료구조 사용:
HashMap 대신 ConcurrentHashMap과 같은 스레드 안전한 자료구조를 사용하여 초기화 시점의 경합 조건을 방지합니다. 이를 통해 초기화 과정에서의 상태 불일치를 최소화할 수 있습니다.

초기화 순서 확인:
서버 시작 시 HashMap을 초기화하는 코드의 순서를 철저히 검토하여, 모든 초기화 작업이 완전하게 끝난 후에만 다른 스레드가 접근할 수 있도록 조치합니다.

지연 초기화 지연 방지:
지연 초기화가 문제가 될 수 있으므로, 필요하다면 서버 시작 시 모든 초기화가 완료되도록 하고, 이후 접근 시 문제가 발생하지 않도록 합니다.

로깅 및 디버깅 강화:
초기화 시점의 동작을 자세히 로깅하여 문제 발생 시 어떤 스레드가 어떤 작업을 하고 있는지 파악할 수 있도록 합니다. 이를 통해 문제의 근본 원인을 정확하게 진단할 수 있습니다.

결론
서버 시작 시 발생하는 문제는 주로 초기화 단계에서의 동기화 문제나 경합 조건 때문에 발생할 가능성이 큽니다. 이를 해결하려면 초기화 과정에서의 동기화를 철저히 관리하고, 스레드 안전한 자료구조를 사용하는 것이 좋습니다. 이를 통해 초기화 시점의 문제가 이후의 지속적인 문제로 이어지는 것을 방지할 수 있습니다.