Threads warten auf einander

Question

Ich versuche, meine Threads aufeinander folgen zu lassen, so wie es eine Rasse ist und wollen, dass die Threads aufeinander warten. Like:

DUCK is on his 1 lap 
PIGGY is on his 1 lap 
ELEFANT is on his 1 lap 
STAR is on his 1 lap 

DUCK is on his 2 lap 
PIGGY is on his 2 lap 
ELEFANT is on his 2 lap 
STAR is on his 2 lap 

und so weiter ..

public class ExThread implements Runnable { 

    String name; 
    Random r = new Random(); 
    int count; 
    int sleepTimer; 

    public ExThread(String name) { 
     this.name = name; 
    } 

    @Override 
    public void run() { 
     try { 
      for(int i = 0; i < 10; i++) { 
       count++; 
       sleepTimer = r.nextInt(1000)+1; 
       Thread.sleep(sleepTimer); 
       System.out.println(
        name + " Starts after "+sleepTimer+" milliseconds break"); 
       System.out.println(
        name+" is on his "+count+" lap"); 

      } 
      System.out.println(name+" completes the race!!!"); 
     } 
     catch (Exception e){} 
    } 

public class ThreadsEx { 

    public static void main(String[] args) throws InterruptedException { 
     Thread t1 = new Thread(new ExThread("STAR")); 
     Thread t2 = new Thread(new ExThread("ELEFANT")); 
     Thread t3 = new Thread(new ExThread("PIGGY")); 
     Thread t4 = new Thread(new ExThread("DUCK")); 
     t1.start(); 
     t2.start(); 
     t3.start(); 
     t4.start(); 
    } 
} 

Answer 1

Sie join nutzen könnten.

for(i = 0; i < threads.length; i++){ 
    threads[i].join(); 
} 

Join wird aktuellen Thread blockieren (Haupt-Thread in Ihrem Fall nehme ich an). Wenn die for-Schleife beendet ist, werden alle Threads mit ihrer Arbeit erledigt.

In Ihrem Fall könnten Sie jeder Thread statt 10.

for(j = 0; j < numberOfLaps; j++){ 
    for(i = 0; i < threads.length; i++){ 
     threads[i].join(); 
    } 
} 

Answer 2

Sie https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/CyclicBarrier.html dafür verwenden, um eine einzelne Runde machen tun.

-Code geht so

import java.util.Random; 
import java.util.concurrent.CyclicBarrier; 

public class ExThread implements Runnable { 

String name; 
Random r = new Random(); 
int count; 
int sleepTimer; 
CyclicBarrier barrier; 

public ExThread(String name, CyclicBarrier barrier) { 
    this.name = name; 
    this.barrier = barrier; 
} 

public static void main(String[] args) throws InterruptedException { 
    CyclicBarrier barrier = new CyclicBarrier(4); 

    Thread t1 = new Thread(new ExThread("STAR", barrier)); 
    Thread t2 = new Thread(new ExThread("ELEFANT", barrier)); 
    Thread t3 = new Thread(new ExThread("PIGGY", barrier)); 
    Thread t4 = new Thread(new ExThread("DUCK", barrier)); 
    t1.start(); 
    t2.start(); 
    t3.start(); 
    t4.start(); 
} 

@Override 
public void run() { 
    try { 
     for (int i = 0; i < 10; i++) { 
      count++; 
      sleepTimer = r.nextInt(1000) + 1; 
      Thread.sleep(sleepTimer); 
      System.out.println(
        name + " Starts after " + sleepTimer + " milliseconds break"); 
      System.out.println(
        name + " is on his " + count + " lap"); 
      barrier.await(); 
     } 

     System.out.println(name + " completes the race!!!"); 
    } catch (Exception e) { 
    } 
} 

}

Answer 3

Erstens ist es sehr schlecht ist, mehrere Instanzen von Random besonders zu haben, wenn sie innerhalb von Millisekunden voneinander erstellt werden (weil sie mit zufälligem Zustand ausgesät Ihr Computer, der sich über diese Zeitskalen nicht viel ändert)

Um die Threads aufeinander warten zu lassen, verwenden Sie eine CyclicBarrier. Die javadoc als ein hervorragendes Beispiel. Ich denke jedoch nicht, dass Sie danach streben, da dies das Rennen selbst stören wird.

Was Sie wollen, ist ein Schiedsrichter-Thread von einigen Arten, der regelmäßig die Runden druckt, die die anderen Threads bisher ausgeführt haben.

Answer 4

Ich nehme an, die Regeln sind:

• Alle Fäden in der gleichen Runde
• Threads können ihre Runde in beliebiger Reihenfolge beenden muss aber auf die nächste Runde nicht fortschreiten kann, bevor alle Threads, die Runde beendet haben.

Diese Regeln erfordern über irgendeine Form der Synchronisation zwischen den Fäden und es gibt ein paar Synchronisierungsoptionen in Java

• Synchronized methods/blocks
• Locks
• Semaphores

Ein anfänglicher Vorschlag wäre, einen Wert zu verwenden, den alle Threads haben Sie können ihre Fortschritte kommunizieren und wissen, ob sie in die nächste Runde kommen oder nicht und den Fortschritt der anderen verfolgen können.

noch einige Hinweise zu Ihrer Implementierung

• System.out.println garantiert nicht die Reihenfolge, in der Nachrichten in Multithread-Anwendungen auf die Konsole gedruckt werden. Sie können in einer anderen Reihenfolge zur Konsole gelangen als diese Methode im Code aufgerufen wird.
• Thread.sleep garantiert keine genaue Schlafzeit.

Answer 5

Sie haben java.util.concurrent zu verwenden, wie folgt aus:

import java.util.Random; 
import java.util.concurrent.CountDownLatch; 
import java.util.concurrent.CyclicBarrier; 

public class RendezVous extends Thread { 

    private final CountDownLatch _start; 
    private final CyclicBarrier _rdv; 
    private final CountDownLatch _stop; 

    public RendezVous(
     String   name, 
     CountDownLatch start, 
     CyclicBarrier rdv, 
     CountDownLatch stop ) 
    { 
     super(name); 
     _start = start; 
     _rdv = rdv; 
     _stop = stop; 
     start(); 
    } 

    @Override 
    public void run() { 
     final Random rnd = new Random(System.currentTimeMillis()); 
     try { 
     System.out.println(getName() + " is started"); 
     _start.countDown(); 
     System.out.println(getName() + " waits for others"); 
     _start.await(); 
     System.out.println(getName() + " is running"); 
     for(int count = 0, i = 0; i < 10; ++i, ++count) { 
      final long sleepTimer = rnd.nextInt(1000) + 1; 
      sleep(sleepTimer); 
      System.out.println(getName() +" is on his " + count + " lap"); 
      _rdv.await(); 
     } 
     _stop.countDown(); 
     _stop.await(); 
     System.out.println(getName() + " completes the race"); 
     } 
     catch(final Exception e) { 
     e.printStackTrace(); 
     } 
    } 

    public static void main(String[] args) { 
     final CountDownLatch start = new CountDownLatch(4); 
     final CyclicBarrier rdv = new CyclicBarrier(4); 
     final CountDownLatch stop = new CountDownLatch(4); 
     new RendezVous("STAR" , start, rdv, stop); 
     new RendezVous("ELEFANT", start, rdv, stop); 
     new RendezVous("PIGGY" , start, rdv, stop); 
     new RendezVous("DUCK" , start, rdv, stop); 
    } 
} 

Ausführungsprotokoll:

DUCK is started 
STAR is started 
DUCK waits for others 
PIGGY is started 
ELEFANT is started 
PIGGY waits for others 
STAR waits for others 
PIGGY is running 
STAR is running 
ELEFANT waits for others 
DUCK is running 
ELEFANT is running 
STAR is on his 0 lap 
PIGGY is on his 0 lap 
DUCK is on his 0 lap 
ELEFANT is on his 0 lap 
DUCK is on his 1 lap 
STAR is on his 1 lap 
ELEFANT is on his 1 lap 
PIGGY is on his 1 lap 
STAR is on his 2 lap 
ELEFANT is on his 2 lap 
PIGGY is on his 2 lap 
DUCK is on his 2 lap 
STAR is on his 3 lap 
PIGGY is on his 3 lap 
ELEFANT is on his 3 lap 
DUCK is on his 3 lap 
DUCK is on his 4 lap 
PIGGY is on his 4 lap 
ELEFANT is on his 4 lap 
STAR is on his 4 lap 
STAR is on his 5 lap 
PIGGY is on his 5 lap 
ELEFANT is on his 5 lap 
DUCK is on his 5 lap 
STAR is on his 6 lap 
DUCK is on his 6 lap 
PIGGY is on his 6 lap 
ELEFANT is on his 6 lap 
PIGGY is on his 7 lap 
ELEFANT is on his 7 lap 
STAR is on his 7 lap 
DUCK is on his 7 lap 
ELEFANT is on his 8 lap 
DUCK is on his 8 lap 
PIGGY is on his 8 lap 
STAR is on his 8 lap 
STAR is on his 9 lap 
ELEFANT is on his 9 lap 
DUCK is on his 9 lap 
PIGGY is on his 9 lap 
DUCK completes the race 
PIGGY completes the race 
ELEFANT completes the race 
STAR completes the race