Как заставить поток ждать, пока переменная не достигнет определенного значения (многопоточная Java)

Если вы используете Java 8, CompletableFuture может вам подойти. Вот полный, надуманный пример, который ожидает, когда 5 клиентов подключатся и отправят сообщение на сервер (смоделировано с использованием BlockingQueue с предложением / опросом).

В этом примере при достижении ожидаемого количества сообщений, подключенных к клиенту, завершается ловушка CompletableFuture, которая затем запускает произвольный код в любом потоке по вашему выбору.

В этом примере у вас нет сложных настроек ожидания / уведомления потока или циклов ожидания при занятости.

package so.thread.state;

import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicLong;

public class Main {

  public static String CONNETED_MSG = "CONNETED";
  public static Long EXPECTED_CONN_COUNT = 5L;

  public static ExecutorService executor = Executors.newCachedThreadPool();
  public static BlockingQueue<String> queue = new LinkedBlockingQueue<>();

  public static AtomicBoolean done = new AtomicBoolean(false);

  public static void main(String[] args) throws Exception {

    // add a "server" thread
    executor.submit(() -> server());

    // add 5 "client" threads
    for (int i = 0; i < EXPECTED_CONN_COUNT; i++) {
      executor.submit(() -> client());
    }

    // clean shut down
    Thread.sleep(TimeUnit.SECONDS.toMillis(1));
    done.set(true);
    Thread.sleep(TimeUnit.SECONDS.toMillis(1));
    executor.shutdown();
    executor.awaitTermination(1, TimeUnit.SECONDS);

  }

  public static void server() {

    print("Server started up");
    // track # of client connections established
    AtomicLong connectionCount = new AtomicLong(0L);

    // at startup, create my "hook"
    CompletableFuture<Long> hook = new CompletableFuture<>();
    hook.thenAcceptAsync(Main::allClientsConnected, executor);

    // consume messages
    while (!done.get()) {
      try {
        String msg = queue.poll(5, TimeUnit.MILLISECONDS);
        if (null != msg) {
          print("Server received client message");
          if (CONNETED_MSG.equals(msg)) {
            long count = connectionCount.incrementAndGet();

            if (count >= EXPECTED_CONN_COUNT) {
              hook.complete(count);
            }
          }
        }

      } catch (Exception e) {
        e.printStackTrace();
      }
    }

    print("Server shut down");

  }

  public static void client() {
    queue.offer(CONNETED_MSG);
    print("Client sent message");
  }

  public static void allClientsConnected(Long count) {
    print("All clients connected, count: " + count);
  }


  public static void print(String msg) {
    System.out.println(String.format("[%s] %s", Thread.currentThread().getName(), msg));
  }
}

Вы получаете такой результат

[pool-1-thread-1] Server started up
[pool-1-thread-5] Client sent message
[pool-1-thread-3] Client sent message
[pool-1-thread-2] Client sent message
[pool-1-thread-6] Client sent message
[pool-1-thread-4] Client sent message
[pool-1-thread-1] Server received client message
[pool-1-thread-1] Server received client message
[pool-1-thread-1] Server received client message
[pool-1-thread-1] Server received client message
[pool-1-thread-1] Server received client message
[pool-1-thread-4] All clients connected, count: 5
[pool-1-thread-1] Server shut down

Ваше выражение:

conhasmap.get(conectionID) != new AtomicLong(0)

всегда будет истинным, потому что вы сравниваете ссылки на объекты, которые никогда не будут равны, вместо значений. Лучшее выражение было бы:

conhasmap.get(conectionID).longValue() != 0L)

, но такой цикл без логики ожидания / уведомления внутри цикла не является хорошей практикой, поскольку он постоянно использует время процессора. Вместо этого каждый поток должен вызывать .wait () в экземпляре AtomicLong, а когда он уменьшается или увеличивается, вы должны вызывать .notifyAll () в экземпляре AtomicLong, чтобы разбудить каждый ожидающий поток для проверки выражения. Класс AtomicLong может уже вызывать метод notifyAll () всякий раз, когда он изменяется, но я не знаю наверняка.

AtomicLong al = conhasmap.get(conectionID);
synchronized(al) {
    while(al.longValue() != 0L) {
        al.wait(100); //wait up to 100 millis to be notified
    }
}

В коде, который увеличивается / уменьшается, это будет выглядеть так:

AtomicLong al = conhasmap.get(conectionID);
synchronized(al) {
    if(al.decrementAndGet() == 0L) {
        al.notifyAll();
    }
}

Я лично не стал бы использовать AtomicLong для этого счетчика, потому что вы не получаете выгоды от безблокировочного поведения AtomicLong. Просто используйте вместо этого java.lang.Long, потому что вам в любом случае потребуется синхронизировать объект счетчика для логики wait () / notify ().