Question

如何顺序执行线程？（例如，我有3个线程T1，T2，T3，我想同时启动这些线程但确保它们应该一个接一个地顺序运行，如第一个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

线程用于同时运行多个任务。

在你的情况下，你需要顺序调用不同的方法而不是线程。
你应该使用：

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

构建一系列可以任何方式执行的任务。

{{1}}

结果是每个任务都可以等待上一个任务的结果，但如果有任何可以并行运行的话，它们可以很好地并行运行。

示例http://ideone.com/VAg8q3演示了3个任务，每个＆gt; = 500毫秒，相互依赖，可以比按顺序实际运行它们快得多。

一些复杂的线程概念

5 个答案: