Question

我有3个线程，我希望它按顺序打印但是当我运行程序时，它会不断得到结果。我不明白它是如何无法按顺序运行线程的。我想继续分别运行线程1和2和3。在每个线程中都有一个循环用于多次打印。所以我想让主线程按顺序运行每个线程。这是我的代码。

 threadMessage("Starting MessageLoop thread");
 long patience = 
 long startTime = System.currentTimeMillis();
 Thread t = new Thread(new MessageLoop());
 Thread t2 = new Thread(new MessageLoop2());
 Thread t3 = new Thread(new MessageLoop3());
 t.setPriority(10);
 t2.setPriority(5);  
 t3.setPriority(1);
 t.start();
 t2.start();
 t3.start();

这是我的线程函数（3个线程）

private static class MessageLoop
    implements Runnable {
    public void run() {

        try {
            for(int i = 0;i<20;i++)
            {      
                 Thread.sleep(1000);
                 // Print a message
                 threadMessage("A");
            }

        } catch (InterruptedException e) {
            threadMessage("thread interrupted");
        }
    }
}
private static class MessageLoop2
implements Runnable {
public void run() {

    try {
        for(int i = 0;i<20;i++)
        {      Thread.sleep(1000);
             // Print a message
             threadMessage("B");
        }

    } catch (InterruptedException e) {
        threadMessage("thread interrupted");
    }
}
 private static class MessageLoop3
implements Runnable {
public void run() {
    String importantInfo = "E";
    try {
       for(int i = 0;i<20;i++)
       {      
           Thread.sleep(1000);
            // Print a message
            threadMessage(importantInfo);
       }

    } catch (InterruptedException e) {
        threadMessage("Thread interrupted");
    }
}

这是我的代码，让它按顺序运行。我想让我的程序分别按照MessageLoop1和2和3的顺序运行。

        while (t.isAlive()) {
        threadMessage("Still waiting...");

        t.join(2000);
        if (((System.currentTimeMillis() - startTime) > patience)
                && t.isAlive()) {
              threadMessage("Tired of waiting!");
              t.interrupt();
                              // Shouldn't be long now
              // -- wait indefinitely
              t.join();

          }
        while(t2.isAlive()){
            threadMessage("Still waiting...");
            t2.join(1000);
            if (((System.currentTimeMillis() - startTime) > patience)
                    && t2.isAlive()) {
                  threadMessage("Tired of waiting!");
                  t2.interrupt();
                                  // Shouldn't be long now
                  // -- wait indefinitely
                  t2.join();

              }
        }
            while(t3.isAlive()){
                threadMessage("Still waiting...");
                t3.join(1000);
                if (((System.currentTimeMillis() - startTime) > patience)
                       && t3.isAlive()) {
                      threadMessage("Tired of waiting!");
                      t3.interrupt();
                                      // Shouldn't be long now
                      // -- wait indefinitely
                      t3.join();

                  }

            }
        }

但结果就像B，A，C一样。谁能解释这种情况呢？我的代码错了吗？谢谢！

Answer 1

这就是线程的工作方式。你没有得到任何保证首先完成的保证 - 这是设计的。

我假设你想要什么，实际上是jdk称之为future和ExecutorService。

（伪代码 - 会出现语法错误）

ExecutorService s = Executors.newCachedThreadPool();
try {
Future f1 = s.submit(new MessageLoop()); 
Future f2 = s.submit(new MessageLoop2()); 
Future f3 = s.submit(new MessageLoop3()); 
f1.await(10, TimeUnit.SECONDS);  // waits for the first thread to finish
// first thread finished now
f2.await(10, TimeUnit.SECONDS); 
// second thread finished now
// ...

} finally  { s.shutdown(); }

非常重要的是管理ExecutorService的正确关闭，因为执行程序服务将管理一些运行的线程，直到你终止它们为止。如果你没有关闭它，那么你的应用程序将不会终止。

Answer 2

是什么让你认为你在掌控秩序？

不会阻止单个MessageLoop实现以任何方式执行。所以他们只会在线程调度的排除中运行。

您需要引入一个共享资源，它在控制线程（尝试强制执行命令）和工作线程之间扮演锁定角色。

在您当前的代码中，控制线程仅在收集工作人员终止时应用特殊序列。这可能已经及早执行和完成。

如果您对顺序执行感兴趣并且不想执行内联任务（与您的控件相同的线程），那么您可能只是按顺序执行线程以实现顺序执行的目标。（启动每个线程并在开始另一个线程之前等待终止）。

当你接受对执行顺序的限制时，你需要一些信号量来协调这样的执行。

如何使线程按顺序运行并多次运行？

2 个答案: