I thread dovrebbero iniziare alla stessa frazione di secondo. Capisco, se lo fai thread1.start()
, ci vorranno alcuni millisecondi prima della prossima esecuzione di thread2.start()
.
È anche possibile o impossibile?
I thread dovrebbero iniziare alla stessa frazione di secondo. Capisco, se lo fai thread1.start()
, ci vorranno alcuni millisecondi prima della prossima esecuzione di thread2.start()
.
È anche possibile o impossibile?
Risposte:
Per avviare i thread esattamente nello stesso momento (almeno il più bene possibile), puoi utilizzare un CyclicBarrier :
// We want to start just 2 threads at the same time, but let's control that
// timing from the main thread. That's why we have 3 "parties" instead of 2.
final CyclicBarrier gate = new CyclicBarrier(3);
Thread t1 = new Thread(){
public void run(){
gate.await();
//do stuff
}};
Thread t2 = new Thread(){
public void run(){
gate.await();
//do stuff
}};
t1.start();
t2.start();
// At this point, t1 and t2 are blocking on the gate.
// Since we gave "3" as the argument, gate is not opened yet.
// Now if we block on the gate from the main thread, it will open
// and all threads will start to do stuff!
gate.await();
System.out.println("all threads started");
Questo non deve essere un CyclicBarrier
, potresti anche usare CountDownLatch
ao anche un lucchetto.
Questo non è ancora sicuro che vengano avviati esattamente nello stesso momento su JVM standard, ma puoi avvicinarti abbastanza. Avvicinarsi è ancora utile quando si eseguono, ad esempio, test delle prestazioni. Ad esempio, se stai cercando di misurare il throughput di una struttura dati con un numero diverso di thread che la colpiscono, vuoi usare questo tipo di costrutto per ottenere il risultato più accurato possibile.
Su altre piattaforme, l'avvio di thread esattamente può essere un requisito molto valido tra l'altro.
CreateEvent
. msdn.microsoft.com/en-us/library/ms686364%28VS.85%29.aspx
Non è possibile, almeno su un computer single core. Ma perché lo vuoi? Anche se sei stato in grado di avviare due thread esattamente nello stesso secondo, avanzeranno in modo diverso perché la pianificazione non è sotto il tuo controllo.
Modifica: (in risposta ad alcuni commenti) È un requisito perfettamente valido per sincronizzare lo stato o l'avanzamento di più thread ed CyclicBarrier
è un ottimo strumento. Ho risposto alla domanda se è possibile avviare più thread esattamente nello stesso momento . CyclicBarrier
garantirà che i thread procedano quando sono esattamente nello stato desiderato, ma non garantisce che inizieranno o riprenderanno esattamente nello stesso momento, anche se potrebbe essere abbastanza vicino. Non si fa menzione delle esigenze di sincronizzazione nella domanda.
Potresti usare un CountDownLatch per questo. Di seguito un esempio. Sebbene t1 e t2 siano avviati, questi thread continuano ad aspettare fino a quando il thread principale conta alla rovescia del latch. Il numero di conto alla rovescia richiesto è indicato nel costruttore. Il latch del conto alla rovescia può essere utilizzato anche per attendere che i thread finiscano l'esecuzione in modo che il thread principale possa procedere ulteriormente (il caso inverso). Questa classe è stata inclusa da Java 1.5.
import java.util.concurrent.CountDownLatch;
public class ThreadExample
{
public static void main(String[] args)
{
CountDownLatch latch = new CountDownLatch(1);
MyThread t1 = new MyThread(latch);
MyThread t2 = new MyThread(latch);
new Thread(t1).start();
new Thread(t2).start();
//Do whatever you want
latch.countDown(); //This will inform all the threads to start
//Continue to do whatever
}
}
class MyThread implements Runnable
{
CountDownLatch latch;
public MyThread(CountDownLatch latch)
{
this.latch = latch;
}
@Override
public void run()
{
try
{
latch.await(); //The thread keeps waiting till it is informed
} catch (InterruptedException e) {
e.printStackTrace();
}
//Do the actual thing
}
}