在一个接一个运行的2个线程之间添加延迟[关闭]

Question

我试图在 2 个线程之间放置 5 秒的间隔，在另一个线程之后运行一个，即假设我的第一个线程打印“X”，将会延迟 5 秒，然后另一个线程打印“Y”，再次打印 5秒延迟，然后是“X”，这会持续下去，说 30 次。

import java.lang.*;
import java.util.concurrent.TimeUnit;
class PingPong implements Runnable
{   String word;
    PingPong(String s){
     word = s;
    }

    public void run()
    {

    try

    {

         for(int  i = 0; i<30; i++)

          {
              System.out.println(word);
              Thread.sleep(100) ;
           }
    } catch (InterruptedException e)

     { e.printStackTrace(); }

   }
   public static void main(String[] args){

     Runnable p1 =  new PingPong("ping");

     Thread  t1 = new Thread(p1);

     t1.start();
     Runnable p2 = new PingPong("pong");

     Thread t2 = new Thread(p2);
     t2.start();
    }
 }

Answer 1

除非您引入某种同步机制，否则线程是相互独立的。因此，您需要做的第一件事是更改您的 PingPong 类以进行同步，每个线程都将等待。

我们称这个对象为ball。您可以在PingPong 的构造函数中传递它。它可以是您想要的任何对象（甚至只是 Object），也可以为它创建自己的小类。

然后在你的循环中，你可以这样做：

synchronized(ball) {
  System.out.println(word);
  Thread.sleep(5000);
}
Thread.sleep(1000);

这样每个线程将阻塞 5 秒，直到它允许另一个线程“占用”球的监视器并输出它的单词。

第二次休眠是任意的，但很重要，这样同一个线程就不会再次获得监视器。

一个稍微复杂但更正确的方法是使用第二个ReentrantLock。同样，您必须将它与之前的 ball 对象一起传递给构造函数。我们称之为lock。

lock.lock();
synchronized(ball) {
  try {
    System.out.println(word);
  } finally {
    lock.unlock();
  }

  Thread.sleep(5000);
}

unlock() 位于finally 块中，以确保如果抛出任何异常，锁不会永远保持锁定状态。

System.out 实际上不需要在try 块内，但这使得代码更优雅，而不是空的try。 sleep() 必须在外面，以确保其他线程在该线程休眠时通过第一个锁进入。

这确保了如果线程 Ping 正在休眠，线程 Pong 会获取lock，因此它将接下来进入synchronized 块。当 Ping 唤醒并走出synchronized 块时，即使恰好在 Pong 之前被调度，它也无法继续，因为它无法占用锁，并且必须等待 Pong 进入 synchronized 块并输出它的单词。