Сон и проверка до тех пор, пока не будет выполнено условие

Question

Есть ли библиотека на Java, которая выполняет следующие действия? A thread следует повторно sleep за миллисекунды до тех пор, пока условие не станет истинным или не будет достигнуто максимальное время.

Эта ситуация возникает, когда тест ждет, пока какое-то условие станет истинным. На состояние влияет другое thread.

[EDIT] Просто, чтобы сделать его более ясным, я хочу, чтобы тест ожидал только X ms, прежде чем он потерпит неудачу. Он не может ждать навсегда, чтобы состояние стало истинным. Я добавляю надуманный пример.

class StateHolder{ 
    boolean active = false; 
    StateHolder(){ 
     new Thread(new Runnable(){ 
      public void run(){ 
       active = true; 
      } 
     }, "State-Changer").start() 
    } 
    boolean isActive(){ 
     return active; 
    } 
} 


class StateHolderTest{ 
    @Test 
    public void shouldTurnActive(){ 
     StateHolder holder = new StateHolder(); 
     assertTrue(holder.isActive); // i want this call not to fail 
    } 
} 

Answer 1

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

Answer 2

EDIT

Большинство ответов сосредоточиться на API низкого уровня с ожидает и оповещает или условий (которые работают более или менее точно так же): трудно получить права, если вы не привыкли к нему. Доказательство. 2 из этих ответов не работают правильно.
java.util.concurrent предлагает вам API высокого уровня, где все эти тонкости были скрыты.

IMHO, нет смысла использовать шаблон ожидания/уведомления, если в параллельном пакете есть встроенный класс, который достигает того же.

---

CountDownLatch с начальным колом-1 делает именно это:

• Когда условие становится истинным, вызовите latch.countdown();
• в вашем ожидании потока, использование: boolean ok = latch.await(1, TimeUnit.SECONDS);

Пропитанный пример:

final CountDownLatch done = new CountDownLatch(1); 

new Thread(new Runnable() { 

    @Override 
    public void run() { 
     longProcessing(); 
     done.countDown(); 
    } 
}).start(); 

//in your waiting thread: 
boolean processingCompleteWithin1Second = done.await(1, TimeUnit.SECONDS); 

Примечание: CountDownLatches являются потокобезопасными.

Answer 3

Вы должны использовать Condition.

Если вы хотели бы иметь тайм-аут в дополнение к условию, см await(long time, TimeUnit unit)

Answer 4

Похоже, что вы хотите сделать, это проверить состояние, а затем, если оно ложно ждать до тайм-аута. Затем, в другом потоке, уведомите об этом после завершения операции.

официанта

synchronized(sharedObject){ 
    if(conditionIsFalse){ 
     sharedObject.wait(timeout); 
     if(conditionIsFalse){ //check if this was woken up by a notify or something else 
      //report some error 
     } 
     else{ 
      //do stuff when true 
     } 
    } 
    else{ 
     //do stuff when true 
    } 
} 

Changer

synchronized(sharedObject){ 
    //do stuff to change the condition 
    sharedObject.notifyAll(); 
} 

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

Answer 5

Я искал решение, подобное тому, что предлагает Awaitility. Думаю, я выбрал неверный пример в моем вопросе. То, что я имел в виду, было в ситуации, когда вы ожидаете, что произойдет асинхронное событие, которое создается сторонней службой, и клиент не может изменить услугу, чтобы предлагать уведомления. Более разумным примером может служить приведенный ниже.

class ThirdPartyService { 

    ThirdPartyService() { 
     new Thread() { 

      public void run() { 
       ServerSocket serverSocket = new ServerSocket(300); 
       Socket socket = serverSocket.accept(); 
       // ... handle socket ... 
      } 
     }.start(); 
    } 
} 

class ThirdPartyTest { 

    @Before 
    public void startThirdPartyService() { 
     new ThirdPartyService(); 
    } 

    @Test 
    public void assertThirdPartyServiceBecomesAvailableForService() { 
     Client client = new Client(); 
     Awaitility.await().atMost(50, SECONDS).untilCall(to(client).canConnectTo(300), equalTo(true)); 
    } 
} 

class Client { 

    public boolean canConnect(int port) { 
     try { 
      Socket socket = new Socket(port); 
      return true; 
     } catch (Exception e) { 
      return false; 
     } 
    } 
} 

Answer 6

Awaitility предлагает простое и чистое решение:.

ждут() atMost (10, СЕК) .until (() -> условие());