Wie Sie System.out-Aufrufe vornehmen, ohne die aktuellen Benutzereingaben (System.in) in der Konsolenanwendung zu beeinflussen?

Question

Ich habe eine Java-Konsole-Anwendung, wo ich ständig Benutzereingaben für Befehle lesen. Einige der Befehle müssen in einem anderen Thread ausgeführt werden und nur einmal innerhalb von 10 Sekunden auf die Ausgabeergebnisse ihrer Ausführung gedruckt werden. Wie mache ich das, ohne einen Benutzer zu beeinflussen?

Beispiel:

ru Hallo! n

Was bedeutet, während der Benutzer eingeben wurde die ‚Ausführen‘ Befehl, machte ein Thread einen auf der Konsole. Gibt es einen Standard Weg, dies wegzulassen?

Answer 1

Sie könnten eine Semaphore verwenden, um mit dieser freigegebenen Ressource unter vielen Threads umzugehen.

Ich schrieb ein einfaches Beispiel basierend auf dieser link. Unten ist die Hauptklasse, die Eingaben von der Konsole erhält.

package multithread; 

import java.io.BufferedReader; 
import java.io.IOException; 
import java.io.InputStreamReader; 
import java.util.concurrent.ExecutorService; 
import java.util.concurrent.Executors; 
import java.util.concurrent.Semaphore; 
import java.util.concurrent.TimeUnit; 

public class MainThread { 

    public static void main(String[] args) throws IOException, InterruptedException { 
     System.out.println("Começando"); 
     Semaphore semaphore = new Semaphore(1); 
     ExecutorService execService = Executors.newFixedThreadPool(8); 
     for (int i = 0; i < 100; i++) { 
      execService.submit(new BackgroundTask(semaphore, i)); 
     } 
     BufferedReader reader = new BufferedReader(new InputStreamReader(System.in)); 
     String line; 
     for (int i = 0; i < 10; i++) { 
      semaphore.acquire(); 
      System.out.print("$ "); 
      line = reader.readLine(); 
      System.out.println(line); 
      semaphore.release(); 
      Thread.sleep(1000); 
     } 
     reader.close(); 
     execService.awaitTermination(10, TimeUnit.MINUTES); 
    } 
} 

Und hier ist die Hintergrund-Task-Klasse, die auf die Konsole druckt.

package multithread; 

import java.util.concurrent.Semaphore; 

public class BackgroundTask implements Runnable { 

    private Semaphore semaphore; 

    private int id; 

    public BackgroundTask(Semaphore semaphore, int id) { 
     this.semaphore = semaphore; 
     this.id = id; 
    } 

    @Override 
    public void run() { 
     for (int i = 0; i < 10; i++) { 
      try { 
       Thread.sleep(1000); 
       semaphore.acquire(); 
       System.out.println("Hello from " + id); 
       semaphore.release(); 
      } catch (InterruptedException e) { 
       e.printStackTrace(); 
      } 
     } 
    } 

}