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

-1

我有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。有谁能解释这种情况吗？我的代码错了吗？谢谢！

来源

2016-03-21 asiandudeCom

您不控制订单;操作系统呢。如果订单很重要，那么它们不应该在单独的线程中。 – duffymo

这就是线程的工作方式。你根本没有得到一个保证，哪一个线程将首先完成 - 这是设计。

我假设你想要的，实际上是jdk所称的未来和一个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的正常关机，执行人服务将管理一对夫妇的运行，直到您终止它们的线程。如果你不关闭它，那么你的应用程序将不会终止。

来源

2016-03-21 18:00:16

是什么让你认为你是控制秩序？

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

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

在您当前的代码中，控制线程只是在收集工作人员的终止时应用特殊顺序。这可能已经被执行并在更早的时间完成。

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

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

来源

2016-03-21 18:05:45 rpy

如果您是按顺序开始线程的话，您仍然会遇到相同的问题;） –

对不起，不清楚。我的意思是表达，开始t1等待终止，开始t2 ......等等。 – rpy

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

回答

相关问题