Выполнение более двух потоков в определенном порядке

Question

Я хочу, чтобы потоки выполнялись в определенном порядке. Предположим, у меня три потока: T1, T2, T2.

T1 печатает 0
T2 печатает 1
T3 печатает 2

Я хочу вывод в порядке , для определенного количества времени.

Если имеется две резьбы T1 и T2. Печать 0 1, 0 1 ... может быть выполнена с использованием Задача производителя-потребителя с использованием synchronization.

Answer 1

Создать класс UnitOfWork:

public class UnitOfWork implements Runnable 
{ 
    String text; 

    public UnitOfWork(String text){ 
     this.text = text; 
    } 

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

А затем создать единую службу нитка Исполнитель:

ExecutorService executor = ExecutorService.newSingleThreadExecutor(); 

, который вы будете использовать, как это:

UnitOfWork uow0 = new UnitOfWork("0"); 
UnitOfWork uow1 = new UnitOfWork("1"); 
UnitOfWork uow2 = new UnitOfWork("2"); 

for(int i = 0; i < 5; i++){ 
    executor.submit(uow0); 
    executor.submit(uow1); 
    executor.submit(uow2); 
} 

Когда вы недовольны пением le thread, вы можете начать использовать службу выполнения нескольких потоков, которая будет одновременно запускать задачи.

Answer 2

Используя метод join() в классе потоков, вы можете достичь этого.

Метод объединения позволяет одному потоку ждать завершения другого. Если t - объект Thread, поток которого в настоящее время выполняется,

t.join();

заставляет текущий поток приостанавливать выполнение до тех пор, пока поток t не завершится. Перегрузки соединения позволяют программисту указать период ожидания. Однако, как и во время сна, соединение зависит от ОС для синхронизации, поэтому вы не должны предполагать, что соединение будет ждать столько, сколько вы укажете.

Как и сон, соединение реагирует на прерывание, выходя из InterruptedException.

Answer 3

Используйте Thread.join, чтобы обеспечить его прекращение до начала следующей нити.

public static void main(String[] args) throws InterruptedException { 
     final Thread th1 = new Thread(new Runnable() { 
      public void run() { 
       try { 
        Thread.sleep((long) (Math.random() * 1000)); 
        System.out.println("Thread 1"); 
       } catch (InterruptedException e) { 
        e.printStackTrace(); 
       } 
      } 
     }); 
     Thread th2 = new Thread(new Runnable() { 
      public void run() { 
       try { 
        Thread.sleep((long) (Math.random() * 1000)); 
        System.out.println("Thread 2"); 
       } catch (InterruptedException e) { 
        e.printStackTrace(); 
       } 
      } 
     }); 
     Thread th3 = new Thread(new Runnable() { 
      public void run() { 
       try { 
        Thread.sleep((long) (Math.random() * 1000)); 
        System.out.println("Thread 3"); 
       } catch (InterruptedException e) { 
        e.printStackTrace(); 
       } 
      } 
     }); 
     th1.start(); 
     th1.join(); 
     th2.start(); 
     th2.join(); 
     th3.start(); 
    } 

Answer 4

Это минималистский кусок кода, который делает буквально что вы просили. Он полагается на механизм wait-notify.

Я согласен с тем, что вам не нужны нитки, отвечающие вашим требованиям. Простой цикл, который печатает 0-1-2, - это все, что вам действительно нужно.

import static java.lang.Thread.currentThread; 

public class A { 
    static int coordinator, timesPrinted; 
    static final int numThreads = 3, timesToPrint = 300; 
    public static void main(String[] args) { 
    for (int i = 0; i < numThreads; i++) { 
     final int myId = i; 
     new Thread(new Runnable() { public void run() { 
     while (true) synchronized (A.class) { 
      if (coordinator%numThreads == myId) { 
      System.out.println(myId+1); 
      coordinator++; 
      if (timesPrinted++ > timesToPrint) currentThread().interrupt(); 
      A.class.notifyAll(); 
      } 
      try {A.class.wait();} catch (InterruptedException e) {break;} 
     } 
     }}).start(); 
    } 
    } 
}