Некоторые сложные концепции Threading

Question

Как выполнять потоки последовательно? (Например, у меня есть 3 темы, Т1, Т2, Т3 и я хочу начать эти нити то же самое время, но гарантировать, что они должны выполняться последовательно друг за другом, как первый T1 затем T2 и наконец T3.)

Thread t1= new Thread(new Runnable() 
     { 
     void run() 
      {System.out.println("inside Thread1");} 
     }); 


    Thread t2= new Thread(new Runnable() 
     { 
     void run() 
      {System.out.println("inside Thread2");} 
     }); 

    Thread t3= new Thread(new Runnable() 
     { 
     void run() 
      {System.out.println("inside Thread3");} 
     }); 

    t1.start(); 
    t2.strat(); 
    t3.start(); 

выход:
внутри thread1
внутри thread2
внутри Thread3
каждый раз, когда у запустить O/P должно быть, как показано выше.

Answer 1

По моему скромному мнению, вам, возможно, не нужны потоки, просто вызовите методы T1(), T2(), T3() последовательно в вашем коде? Темы используются для одновременного запуска нескольких задач.

Answer 2

Вы можете синхронизировать эти потоки через flag/s. Вы также можете использовать встроенные синхронизаторы, предоставляемые Java, например BlockingQueue.

Answer 3

Используйте BlockingQueues для синхронизации нитей

final BlockingQueue q1 = new SynchronousQueue(); 
    final BlockingQueue q2 = new SynchronousQueue(); 
    Thread t1 = new Thread() { 
     public void run() { 
      ... 
      try { 
       q1.put(new Object()); 
      } catch (InterruptedException e) { 
      } 
     }; 
    }; 
    Thread t2 = new Thread() { 
     public void run() { 
      try { 
       q1.take(); 
       ... 
       q2.put(new Object()); 
      } catch (InterruptedException e) { 
      } 
     } 
    }; 
    Thread t3 = new Thread() { 
     public void run() { 
      try { 
       q2.take(); 
       ... 
      } catch (InterruptedException e) { 
      } 
     } 
    }; 
    t1.start(); 
    t2.start(); 
    t3.start(); 

Answer 4

Темы используются для выполнения нескольких задач, в то же время.

В вашем случае вам нужны разные методы, называемые последовательно, а не Threads.
Вы должны использовать:

class Methods_Than_Threads{ 
void T1() 
{ 
    //something 
} 
void T2() 
{ 
    //something 
} 
void T3() 
{ 
    //something 
} 
public static void main(String []args) 
{ 
    T1();//First T1 
    T2();//Second T2 
    T3();//Third T3 
} 
} 

Answer 5

Вы должны отделить реальные задачи, от того, как они выполняются. То есть не расширяйте Thread и перезапишите run, вместо этого выполните Runnable как задачу и не заботитесь о том, как он выполняется.

Таким образом, вы можете проектировать (+ изменить позже) способ выполнения задач независимо от фактической реализации задачи.

E.g. Вызовите каждый из .run() непосредственно, если вы хотите выполнить их после друг друга или позволить некоторым Executor обрабатывать их или даже запускать их через new Thread вручную.

Если им нужно подождать друг на друга, вы также можете использовать Future. Например:

class ProcessingChainElement implements Callable<String> { 
    private final Future<String> previous; 
    public ProcessingChainElement(Future<String> previousResult) { 
     previous = previousResult; 
    } 
    @Override 
    public String call() throws Exception { 
     // prepare something that may take some time but does not depend on 
     // any previous result 
     Thread.sleep(500); 

     // get result from previous task, this blocks until it is available 
     result = previous.get() + " [" + System.currentTimeMillis() + "]"; 

     return result; 
    } 
} 

И постройте цепочку задач, которые могут быть выполнены любым возможным способом.

ExecutorService executor = Executors.newFixedThreadPool(3); 
Future<String> result1 = executor.submit(... 
Future<String> result2 = executor.submit(new ProcessingChainElement(result1)); 
... 

Результат является то, что каждая из них может ждать результатов предыдущей задачи, но может очень хорошо работать параллельно, если есть что-то, что может работать параллельно.

Пример http://ideone.com/VAg8q3 показывает, что 3 задачи, которые занимают> = 500 мс каждый и зависят друг от друга, могут выполняться намного быстрее, чем их выполнение в последовательности.