Ordre d'exécution des threads dans l'ordre dans lequel ils ont été créés / démarrés

Sonne comme vous voulez ExecutorService.invokeAllqui sera de retour les résultats de threads de travail dans un ordre fixe, même si elles peuvent être programmées dans un ordre arbitraire:

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class ThreadOrdering {
static int NUM_THREADS = 10;
public static void main(String[] args) {
ExecutorService exec = Executors.newFixedThreadPool(NUM_THREADS);
class MyCallable implements Callable<Integer> {
private final int threadnumber;
MyCallable(int threadnumber){
this.threadnumber = threadnumber;
}
public Integer call() {
System.out.println("Running thread #" + threadnumber);
return threadnumber;
}
}
List<Callable<Integer>> callables =
new ArrayList<Callable<Integer>>();
for(int i=1; i<=NUM_THREADS; i++) {
callables.add(new MyCallable(i));
}
try {
List<Future<Integer>> results =
exec.invokeAll(callables);
for(Future<Integer> result: results) {
System.out.println("Got result of thread #" + result.get());
}
} catch (InterruptedException ex) {
ex.printStackTrace();
} catch (ExecutionException ex) {
ex.printStackTrace();
} finally {
exec.shutdownNow();
}
}
}

Tout simplement, l'ordonnancement de threads est de durée indéterminée.

http://www.janeg.ca/scjp/threads/scheduling.html Mort de domaine - ne cliquez pas sur

WaybackMachine version de la page mentionnée ci-dessus

La plus longue réponse, c'est que si vous voulez faire cela, vous devez manuellement attendre pour chaque thread d'achever ses travaux avant d'autoriser l'autre à s'exécuter. Notez que dans ce mode, tous les threads encore interleave, mais ils ne seront pas faire le travail jusqu'à ce que vous donner le feu vert. Jetez un oeil à le synchroniser mot réservé.

Ici un moyen de le faire sans avoir un maître thread qui attend chaque résultat. Au lieu de cela, avoir les threads de partager un objet qui ordonne les résultats.

import java.util.*;
public class OrderThreads {
public static void main(String... args) {
Results results = new Results();
new Thread(new Task(0, "red", results)).start();
new Thread(new Task(1, "orange", results)).start();
new Thread(new Task(2, "yellow", results)).start();
new Thread(new Task(3, "green", results)).start();
new Thread(new Task(4, "blue", results)).start();
new Thread(new Task(5, "indigo", results)).start();
new Thread(new Task(6, "violet", results)).start();
}
}
class Results {
private List<String> results = new ArrayList<String>();
private int i = 0;
public synchronized void submit(int order, String result) {
while (results.size() <= order) results.add(null);
results.set(order, result);
while ((i < results.size()) && (results.get(i) != null)) {
System.out.println("result delivered: " + i + " " + results.get(i));
++i;
}
}
}
class Task implements Runnable {
private final int order;
private final String result;
private final Results results;
public Task(int order, String result, Results results) {
this.order = order;
this.result = result;
this.results = results;
}
public void run() {
try {
Thread.sleep(Math.abs(result.hashCode() % 1000)); //simulate a long-running computation
}
catch (InterruptedException e) {} //you'd want to think about what to do if interrupted
System.out.println("task finished: " + order + " " + result);
results.submit(order, result);
}
}

Une solution simple serait d'utiliser un tableau A de serrures (un verrou par thread). Lorsque le thread i commence ses exécutions, il acquiert ses associés de verrouillage A[i]. Quand il est prêt à fusionner ses résultats, il libère sa serrure A[i] et attend pour les serrures A[0], A[1], ..., A[i - 1] être rejetée; puis il fusionne les résultats.

(Dans ce contexte, le fil i signifie la i-th lancé fil)

Je ne sais pas ce que les classes à utiliser en Java, mais il doit être facile à mettre en œuvre. Vous pouvez commencer la lecture cette.

Si vous avez d'autres questions, n'hésitez pas à demander.

De contrôle de l'exécution du fil de commande peut être mis en place assez facilement avec les sémaphores. Le code ci-joint est basé sur les idées présentées dans Schildt livre sur Java (La référence complète....).
//Basé sur les idées présentées dans:
//Schildt H.: Java.L'.Complète.De référence.9.Edition.

import java.util.concurrent.Semaphore;
class Manager {
int n;
//Initially red on semaphores 2&3; green semaphore 1.
static Semaphore SemFirst = new Semaphore(1);
static Semaphore SemSecond = new Semaphore(0);
static Semaphore SemThird = new Semaphore(0);
void firstAction () {
try {
SemFirst.acquire();
} catch(InterruptedException e) {
System.out.println("Exception InterruptedException catched");
}
System.out.println("First: " );
System.out.println("-----> 111");
SemSecond.release();
}
void secondAction() {
try{
SemSecond.acquire();
} catch(InterruptedException e) {
System.out.println("Exception InterruptedException catched");
}
System.out.println("Second: ");
System.out.println("-----> 222");
SemThird.release();
}
void thirdAction() {
try{
SemThird.acquire();
} catch(InterruptedException e) {
System.out.println("Exception InterruptedException catched");
}
System.out.println("Third: ");
System.out.println("-----> 333");
SemFirst.release();
}
}
class Thread1 implements Runnable {
Manager q;
Thread1(Manager q) {
this.q = q;
new Thread(this, "Thread1").start();
}
public void run() {
q.firstAction();
}
}
class Thread2 implements Runnable {
Manager q;
Thread2(Manager q) {
this.q = q;
new Thread(this, "Thread2").start();
}
public void run() {
q.secondAction();
}
}
class Thread3 implements Runnable {
Manager q;
Thread3(Manager q) {
this.q = q;
new Thread(this, "Thread3").start();
}
public void run() {
q.thirdAction();
}
}
class ThreadOrder {
public static void main(String args[]) {
Manager q = new Manager();
new Thread3(q);
new Thread2(q);
new Thread1(q);
}
}