一些复杂的线程概念[重复]答案

【问题标题】：Some complex Threading concept [duplicate]一些复杂的线程概念[重复]
【发布时间】：2013-08-05 11:18:11
【问题描述】：

如何顺序执行线程？（例如，我有 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();

输出：
线程1内
线程2内
在 Thread3
每次运行 o/p 应该如上所示。

【问题讨论】：

在一个线程中运行你的东西怎么样？
你能澄清你的问题吗？目前对我来说，问题是你想用这个实现什么。
“线程”可能是指“任务”。如果不是，那么这是一个关于你永远不想出现在功能应用程序中的行为的人为问题。
如果您指的是任务，请参阅 SingleThreadPoolExecutor。
如果你在运行，多个任务顺序执行，为什么需要多个线程？你可以用单线程来做。

标签： java

【解决方案1】：

以我的拙见，您可能不需要线程，只需在代码中依次调用 T1()、T2()、T3() 方法？线程用于并行运行多个任务。

【讨论】：

但是伙计，如果面试官问我该怎么办，我最近在 ALcatel-lucent 遇到了同样的问题。

【解决方案2】：

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

【讨论】：

我想这也是针对任务而不是线程的。可以提供样品吗？
你可以为同一个任务绑定多个线程。问题只是关于执行多个线程。

【解决方案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();

【讨论】：

【解决方案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
}
}

【讨论】：

【解决方案5】：

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

通过这种方式，您可以独立于任务的实际实现来设计（稍后更改）执行任务的方式。

例如如果您想一个接一个地执行它们，或者让一些Executor 处理它们，甚至通过new Thread 手动运行它们，请直接调用每个.run()。

如果他们必须互相等待，您也可以使用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 毫秒且相互依赖的任务比实际按顺序运行要快得多。

【讨论】：