Le sommeil et vérifier jusqu'à ce que la condition est vraie

Est-il une bibliothèque en Java qui est le suivant? Un thread doit à plusieurs reprises sleep pour les x millisecondes jusqu'à ce qu'une condition est vraie ou le temps maximum est atteint.

Cette situation se produit généralement quand un test attend une condition pour devenir vrai. La condition est influencé par une autre thread.

[EDIT]Juste pour la rendre plus claire, je veux le test d'attendre que X ms avant qu'il tombe en panne. Il ne peut pas attendre longtemps pour qu'une condition devienne vraie. Je suis l'ajout d'un exemple artificiel.

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 
    }
}

Si il y a un autre thread de contrôle, vous pouvez définir une véritable "terminé" signal wait/notify au lieu d'interrogation?
La condition est influencé par un autre thread, je Peux dire que je peux utiliser le Thread rejoindre ici? De toute façon +1 pour la question.

InformationsquelleAutor Rag | 2013-01-22

19

MODIFIER

La plupart des réponses se concentrent sur le faible niveau de l'API avec les attentes et les informe ou des Conditions (qui fonctionnent plus ou moins de la même manière): il est difficile d'obtenir le droit quand vous n'y êtes pas habitué. La preuve: 2 de ces réponses n'utilisez pas attendre correctement.

java.util.simultanées vous offre un haut niveau d'API où toutes ces subtilités ont été cachés.

À mon humble avis, il n'y a pas de point à l'aide d'un wait/notify modèle quand il y a une classe intégrée dans le simultanées package qui permet d'obtenir le même.

Un CountDownLatch avec un décompte de 1 est exactement cela:
- Quand la condition devient vraie, appel latch.countdown();
- dans votre thread en attente, utilisez : boolean ok = latch.await(1, TimeUnit.SECONDS);
Exemple artificiel:
```
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);
```
Remarque: CountDownLatches sont thread-safe.
- C'est vraiment la meilleure réponse, une propreté et une solution efficace...
InformationsquelleAutor assylias
8

Vous devriez être en utilisant un Condition.

Si vous souhaitez avoir un délai d'attente en plus de la condition, voir attendre(longtemps, TimeUnit unit)

InformationsquelleAutor Alex DiCarlo
8

Awaitility offre un moyen simple et propre solution:

await().atMost(10, SECONDES).jusqu'à ce que(() -> condition());

InformationsquelleAutor thisismydesign

Je cherchais une solution à ce Awaitility fournit. Je crois que j'ai choisi un exemple incorrect dans ma question. Ce que je voulais dire était dans une situation où vous vous attendez à un événement asynchrone à produire qui est créé par un service tiers et le client ne peut pas modifier le service de notifications d'offres. Un plus raisonnable serait par exemple celle ci-dessous.

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;
        }
    }
}

Précisément, Condition ou d'autres Java asynchronicité des solutions basées sur finissent par encombrer le code et de le lire vraiment pas naturel pour les cas 3ème partie des bibliothèques qui n'ont pas de point d'entrée à un synchrones attendre sur leur traitement en arrière-plan. J'ai fini par utiliser awaitility trop même dans les tests de code, comme c'est la solution la mieux adaptée dans ce cas, surtout à partir d'une lisibilité / maintenabilité point de vue.

InformationsquelleAutor Rag

0

Vous ne devriez pas dormir et de vérifier et de sommeil et de vérifier. Vous voulez attendre sur une variable de condition et la condition de changer et de se réveiller le fil quand il est temps de faire quelque chose.
- veuillez voir ma description améliorée.
InformationsquelleAutor jco.owens
-1

Il semble que ce que vous voulez faire est de vérifier l'état et puis si c'est faux attendre jusqu'à ce que délai. Puis, dans l'autre thread, notifyAll une fois que l'opération est terminée.

Garçon
```
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
  }
}
```
Changeur de
```
  synchronized(sharedObject){
   //do stuff to change the condition
   sharedObject.notifyAll();
 }
```
Qui devrait faire l'affaire pour vous. Vous pouvez également le faire à l'aide d'un verrou de rotation, mais vous devez vérifier le délai d'attente à chaque fois que vous allez à travers la boucle. Le code pourrait en fait être un peu plus simple si.
- vous ne devez pas utiliser d'attendre à l'extérieur d'une boucle while.
InformationsquelleAutor Jonathan

Vous devez vous connecter pour publier un commentaire.