обратный отсчет нескольких потоков java

Question

У меня есть 4 темы, ведьма печатает цифры от 15 до 0. Я хочу контролировать выполнение моих потоков, например, я хочу сначала нарисовать D, чтобы закончить, а после него нить C и после него нить B и, наконец, нить А. На данный момент они делают все это параллельно. Как это изменить? какие-либо предложения?

Вот мой код:

// Suspending and resuming a thread for Java 2 
class NewThread implements Runnable { 
    String name; // name of thread 
    Thread t; 
    boolean suspendFlag; 
    NewThread(String threadname) { 
     name = threadname; 
     t = new Thread(this, name); 
     System.out.println("New thread: " + t); 
     suspendFlag = false; 
     t.start(); // Start the thread 
    } 
    // This is the entry point for thread. 
    public void run() { 
     try { 
     for(int i = 15; i > 0; i--) { 
     System.out.println(name + ": " + i); 
     Thread.sleep(200); 
     synchronized(this) { 
      while(suspendFlag) { 
       wait(); 
      } 
      } 
     } 
     } catch (InterruptedException e) { 
     System.out.println(name + " interrupted."); 
     } 
     System.out.println(name + " exiting."); 
    } 
    void mysuspend() { 
     suspendFlag = true; 
    } 
    synchronized void myresume() { 
     suspendFlag = false; 
     notify(); 
    } 
} 

public class SuspendResume { 
    public static void main(String args[]) { 
     NewThread A = new NewThread("A"); 
     NewThread B = new NewThread("B"); 
     NewThread C = new NewThread("C"); 
     NewThread D = new NewThread("D"); 
//  try { 
//  System.out.println("****************************************************************"); 
//  System.out.println(A.t.getState()); 
//  System.out.println(B.t.getState()); 
//  System.out.println(C.t.getState()); 
//  System.out.println(D.t.getState()); 
//   
//  if(D.t.isAlive()) 
//  { 
//   System.out.println("Bla bla bla"); 
//  } 
//    
//  Thread.sleep(1000); 
//  A.mysuspend(); 
//  System.out.println("Suspending thread One"); 
//  Thread.sleep(1000); 
//   A.myresume(); 
//   System.out.println("Resuming thread One"); 
//   B.mysuspend(); 
//   System.out.println("Suspending thread Two"); 
//   Thread.sleep(1000); 
//   B.myresume(); 
//   System.out.println("Resuming thread Two"); 
//   
//   
//   
//  } catch (InterruptedException e) { 
//   System.out.println("Main thread Interrupted"); 
//  } 
     // wait for threads to finish 
     try { 
     System.out.println("Waiting for threads to finish."); 
     A.t.join(); 
     B.t.join(); 
     C.t.join(); 
     D.t.join(); 
     } catch (InterruptedException e) { 
     System.out.println("Main thread Interrupted"); 
     } 
     System.out.println("Main thread exiting."); 
    } 
} 

Answer 1

Просто сделать это с основной():

NewThread A = new NewThread("A"); 
    A.t.join(); 
    NewThread B = new NewThread("B"); 
    B.t.join(); 
    NewThread C = new NewThread("C"); 
    C.t.join(); 
    NewThread D = new NewThread("D"); 
    D.t.join(); 

Таким образом, порядок будет: A-B-C-D

Answer 2

Я думаю, вы должны разработать структуру первого класса обслуживания. Я могу предложить следующее:

public class Service { 

    private List<Service> dependencies; 

    // Starts service. 
    // It should wait until all dependencies started using awaitStart method and then start itself 
    public void start(); 

    // Blocks current thread until service is started. 
    // If it is started returns immediately. 
    public void awaitStart(); 

    // Stops service. 
    // Awaits until all dependencies are stopped using awaitStop. 
    public void stop(); 

    // Blocks current thread until service is stopped. 
    // If it is already stops returns immediately 
    public void awaitStop(); 

    // Actual code that has service specific code. 
    // This method may be invoked as last line in 'start' method. 
    public void run(); 
} 

Следующая проблема заключается в реализации start и awaitStart (stop методы реализованы аналогичные). Я рекомендую использовать инструменты от java.util.concurrent для реализации метода awaitStart. Например. CountDownLatch. У каждой службы есть своя защелка, которая указывает, что сервер запущен. Таким образом, код для awaitStart и start:

private CountDownLatch started = new CountDownLatch(1); 

public void awaitStart() { 
    started.await(); 
} 

public void start() { 
    for (Service service : dependencies) { 
     service.awaitStart(); 
    } 
    System.out.println("Service " + name + " is started"); 
    started.countDown(); 
    run(); 
}