按顺序运行Java线程

Question

你将如何顺序执行三个线程？例如.Thread1,Thread2,Thread3.无法将一个Thread的引用传递给另一个Thread并从run()方法调用.

所以代码应该是这样的:

 Thread1.start();
 Thread2.start();
 Thread3.start();

应该是

 Printing Thread1
 Printing Thread2
 Printing Thread3

这可以通过使用ThreadPoolExecutor并使用阻塞队列来实现,但即使这样也不是可接受的答案.

Answer 1

你可以使用Executors.newSingleThreadExecutor(),但严格来说这只启动一个 Thread,所以可能不是预期的解决方案.

仅使用Thread类的最简单的解决方案:

Thread1.start();
Thread1.join();
Thread2.start();
Thread2.join();
Thread3.start();
Thread3.join();

(为了清晰起见,我省略了异常处理,Thread.join()可以抛出InterruptedException)

Answer 2

最简单的答案是

Thread1.run();
Thread2.run();
Thread3.run();

不切实际的问题是他们经常有一个无法解释的答案.;)

拥有线程的重点是同时运行它们.如果您根本不这样做,请不要使用线程.

你可能会说; 你不能调用run()方法,在这种情况下你不能使用ThreadPoolExecutor,因为它为你调用run()方法.即那是submit()最终做的事情.

编辑:结果是完全确定的,因为有一个涉及的线程是不可靠的.

static class PrintThread extends Thread {
    public PrintThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++)
            System.out.println(getName() + ": " + i);
    }
}

public static void main(String args[]) {
    Thread thread1 = new PrintThread("A");
    Thread thread2 = new PrintThread("B");
    Thread thread3 = new PrintThread("C");

    thread1.run();
    thread2.run();
    thread3.run();
}

打印

A: 0
A: 1
.. deleted ..
C: 98
C: 99

正如所料.

Answer 3

在java.util.concurrent包中使用ExecutorService.更精确地使用Executors.newSingleThreadExecutor();

Answer 4

由于这是一个面试问题，他们正在寻找具体的知识，而不是“嗯，这样做显然更好”的答案。他们似乎还可能会提出一个又一个的解决方案，直到得到他们想要的答案。

他们很可能想看看您是否可以自己实现线程间通信。但他们不希望您以简单的方式做到这一点（可用线程参考）。否则，你就可以这样做thread.join()。

因此，所有三个线程都获取一些共享内存（同步静态类）。让每个线程检查一个public static int nextThread(). 在成功比较它们是下一个线程后，它们应该执行其工作并更新public static setNextThread(int value)为要处理的下一个线程的值。

关键是以线程安全的方式做到这一点；但是，如果您可以保证唯一的线程标识符并确保没有两个线程具有相同的标识符，您甚至可以（通过仔细编码）在不同步的情况下做到这一点。

Answer 5

线程可以通过使用 ExecutorService 顺序执行。找到下面的例子。

public class SeqThread {

    public static void main(String[] arg) {
          new SeqThread().execute();
    }

    public void execute() {
        try {
        ExecutorService executor = Executors.newFixedThreadPool(1);
        executor.submit(R);
        executor.submit(R2);
        executor.shutdown();

            executor.awaitTermination(10, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    Runnable R = new Runnable() {

        @Override
        public void run() {
            // TODO Auto-generated method stub
            for(int i=0;i<10;i++)
            {
                System.out.println("In Thread One "+i);
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    };

    Runnable R2 = new Runnable() {

        @Override
        public void run() {
            // TODO Auto-generated method stub
            for(int i=0;i<10;i++)
            {
                System.out.println("In Thread Two="+i);
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    };
}