Ordenar hilos para que se ejecuten en el orden en que se crearon/iniciaron

Question

¿Cómo puedo pedir hilos en el orden en que se crearon las instancias.e.g. ¿Cómo puedo hacer que el programa de abajo imprima los números 1 ... 10 en orden?

public class ThreadOrdering { 
    public static void main(String[] args) { 

     class MyRunnable implements Runnable{ 
      private final int threadnumber; 

      MyRunnable(int threadnumber){ 
       this.threadnumber = threadnumber; 
      } 

      public void run() { 
       System.out.println(threadnumber); 
      } 
     } 

     for(int i=1; i<=10; i++){ 
      new Thread(new MyRunnable(i)).start(); 
     } 
    } 
} 

Answer 1

suena como usted quiere ExecutorService.invokeAll, que devolverá resultados de subprocesos de trabajo en un orden fijo, a pesar de que pueden ser programadas en orden arbitrario:

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(); 
     } 
    } 

} 

Answer 2

En pocas palabras, la programación de los hilos es indeterminada.

http://www.janeg.ca/scjp/threads/scheduling.html dominio Muerto - no haga clic

WaybackMachine version of the above page

La respuesta larga es que si usted quiere hacer esto, tendrá que esperar manualmente para cada hilo para completar su labor antes de permitir que otro se ejecute. Tenga en cuenta que de esta manera, todos los hilos seguirán intercalados pero no realizarán ningún trabajo hasta que usted dé el visto bueno. Eche un vistazo a la palabra reservada de sincronización.

Answer 3

Si necesita un control detallado, no debe usar subprocesos, sino buscar utilizando un Ejecutor adecuado con Callables o Runnables. Vea la clase de ejecutores para una amplia selección.

Answer 4

Puede encadenarlos, es decir, haga que el primero inicie el segundo, el segundo inicie el tercero, etc. Realmente no se ejecutarán al mismo tiempo, excepto un poco de superposición cuando se inicie cada uno .

public class ThreadOrdering 
{ 
    public static void main(String[] args) 
    { 
     MyRunnable[] threads = new MyRunnable[10];//index 0 represents thread 1; 
     for(int i=1; i<=10; i++) 
      threads[i] = new MyRunnable(i, threads); 
     new Thread(threads[0].start); 
    } 
} 

public class MyRunnable extends Runnable 
{ 
    int threadNumber; 
    MyRunnable[] threads; 

    public MyRunnable(int threadNumber, MyRunnable[] threads) 
    { 
     this.threadnumber = threadnumber; 
     this.threads = threads; 
    } 

    public void run() 
    { 
     System.out.println(threadnumber); 
     if(threadnumber!=10) 
      new Thread(threadnumber).start(); 
    } 
} 

Answer 5

"En realidad tengo algunas partes que quiero para ejecutar en paralelo, y luego una vez que se generan los resultados, quiero combinar los resultados en cierto orden." Gracias, esto aclara lo que estás preguntando.

Puede ejecutarlos todos a la vez, pero lo importante es obtener sus resultados en orden cuando los hilos finalizan su cálculo. O bien Thread#join() en el orden en el que desea obtener sus resultados, o simplemente Thread#join() y repítelos para obtener sus resultados.

// Joins the threads back to the main thread in the order we want their results. 
public class ThreadOrdering { 
    private class MyWorker extends Thread { 
     final int input; 
     int result; 
     MyWorker(final int input) { 
      this.input = input; 
     } 
     @Override 
     public void run() { 
      this.result = input; // Or some other computation. 
     } 
     int getResult() { return result; } 
    } 

    public static void main(String[] args) throws InterruptedException { 
     MyWorker[] workers = new MyWorker[10]; 
     for(int i=1; i<=10; i++) { 
      workers[i] = new MyWorker(i); 
      workers[i].start(); 
     } 

     // Assume it may take a while to do the real computation in the threads. 

     for (MyWorker worker : workers) { 
      // This can throw InterruptedException, but we're just passing that. 
      worker.join(); 
      System.out.println(worker.getResult()); 
     } 
    } 
} 

Answer 6

Una solución simple sería la de utilizar una matriz A de cerraduras (una cerradura por hilo). Cuando el hilo i comienza sus ejecuciones, adquiere su cerradura asociada A[i]. Cuando esté listo para fusionar sus resultados, liberará su bloqueo A[i] y esperará a que se liberen los bloqueos A[0], A[1], ..., A[i - 1]; luego combina los resultados.

(En este contexto, significa que el hilo ii -ésimo lanzó hilo)

No sé qué clases para usar en Java, pero debe ser fácil de implementar. Puede comenzar a leer this.

Si tiene más preguntas, no dude en preguntar.

Answer 7

Aquí está una manera de hacerlo sin tener un hilo maestro que espera cada resultado. En cambio, haga que los subprocesos de trabajo compartan un objeto que ordena los resultados.

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); 
    } 
} 

Answer 8

public static void main(String[] args) throws InterruptedException{ 
    MyRunnable r = new MyRunnable(); 
    Thread t1 = new Thread(r,"A"); 
    Thread t2 = new Thread(r,"B"); 
    Thread t3 = new Thread(r,"C"); 

    t1.start(); 
    Thread.sleep(1000); 

    t2.start(); 
    Thread.sleep(1000); 
    t3.start(); 
} 

Answer 9

de control de orden de ejecución de rosca puede ser implementado fácilmente con los semáforos. El código adjunto se basa en las ideas presentadas en el libro de Schildt sobre Java (La referencia completa ...). // Basado en las ideas presentadas en: // Schildt H .: Java.The.Complete.Reference.9th.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); 
    } 
}