-2

如何顺序执行线程？（例如，我有 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 应该如上图所示。

4

5 回答 5

6

在我看来，您可能不需要线程，只需在代码中按顺序调用 T1()、T2()、T3() 方法？线程用于并行运行多个任务。

于 2013-08-05T11:22:42.267 回答
1

您应该将实际任务与其执行方式分开。即不扩展Thread和覆盖run，而是Runnable作为任务实现并且不关心它的执行方式。

这样，您就可以设计（稍后更改）您执行任务的方式，而与任务的实际实现无关。

例如调用每个.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 毫秒且相互依赖的任务比实际按顺序运行它们要快得多。

于 2013-08-05T12:43:49.983 回答
1
线程用于同时运行多个任务。

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

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
}
}
于 2013-08-05T11:53:56.287 回答
1

使用 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();
于 2013-08-05T11:37:26.487 回答
1

您可以通过flag/s同步这些线程 。您还可以使用 Java 提供的内置同步器，例如BlockingQueue。

于 2013-08-05T11:23:06.097 回答