Exécution synchrone entre méthodes et écouteur dans Java

Question

En supposant que je dois écrire 10 fois consécutivement sur un port série.

for (int i = 1; i <= 10; i++) { 
    serialPort.writeInt(i); 
// wait until SerialPortEventListener receives something then write again 
    } 

ou:

void writeMoreDate(){ 
     serialPort.writeInt(something); 
    // wait until SerialPortEventListener receives something then write again 
     serialPort.writeInt(something; 
    // wait until SerialPortEventListener receives something then write again 
     serialPort.writeInt(something); 
} 

Et j'ai un port série événement Listener, qui se déclenche chaque fois que j'écris quelque chose, et appelle .map() méthode.

@Override 
    public void serialEvent(SerialPortEvent event) { 
     if (event.isRXCHAR() && event.getEventValue() > 0) { 

//when data arrived do something and notify that next method can execute!    
     } 
    } 

Comment puis-je faire attendre que serialEvent reçoive quelque chose?

-Ce est comment je manié ce jusqu'à maintenant en utilisant java.util.concurrent.Semaphore:

ex:

Semaphore semaphore = new Semaphore(MAX_CONCURRENT_THREADS, true); 

     void writeMoreDate(){ 
      Runnable runnable() -> { 
      serialPort.writeInt(something); 
      semaphore.acquire(); 
      serialPort.writeInt(something; 
      semaphore.acquire(); 
      serialPort.writeInt(something); 
      semaphore.acquire(); 
      } 
       new Thread(runnable).start(); 
      } 

et série Listener:

@Override 
    public void serialEvent(SerialPortEvent event) { 
     if (event.isRXCHAR() && event.getEventValue() > 0) { 
       semaphore.release(); 
     } 
    } 

Mais je ne suis pas sûr si c'est la bonne solution. Merci.

Answer 1

Je voudrais essayer de le faire un peu plus récursivement au lieu d'utiliser une boucle for. Quelque chose le long des lignes de:

private int activeIndex = -1; 
private int maxIndex = -1; 

private void write(int currentIndex, int maxIndex){ 
    if(maxIndex < currentIndex) 
     return; 

    activeIndex = currentIndex; 
    maxIndex = maxIndex; 

    serialPort.writeInt(currentIndex); 
} 

Et puis dans votre écouteur d'événement vous déclencher le prochain événement d'écriture après le dernier événement a fini ...

public void serialEvent(SerialPortEvent event) { 
    if (event.isRXCHAR() && event.getEventValue() > 0) { 
     ..... 

     write(activeIndex + 1, maxIndex); 
    } 
} 

Il serait beaucoup plus propre si vous pouviez en quelque sorte passer les indices courant/max à travers le SerialPortEvent au lieu d'utiliser des variables de classe pour contenir les données, mais je ne suis pas assez familier avec ces classes pour savoir si c'est possible.

Ainsi, à partir de votre exemple, vous pouvez l'utiliser avec:

write(0, 10);