Java 如何从另一个线程启动一个线程，并在执行后重新启动一个线程？

我有两个线程，“主”线程启动一个辅助线程来运行一个小进程

“主”线程必须等待次线程几秒钟才能完成进程，之后，无论次线程的进程发生了什么，“主”线程都必须重新启动

如果辅助进程提前结束，“主”线程必须重新开始工作

如何从另一个线程启动一个线程，等待执行结束，然后在执行结束后重新启动该线程

我这里有一个代码，但是ExampleRun类必须等待，例如，10秒，然后重新启动，不管MyProcess发生了什么

public class ExampleRun {
public static void main(String[] args) {

    MyProcess t = new MyProcess();
    t.start();

    synchronized (t) {
        try {
            t.wait();
        } catch (InterruptedException e) {
            System.out.println("Error");
        }
    }
}

}

公共类MyProcess扩展线程{
公开募捐{
系统输出打印项次（“开始”）；
已同步（此）{
对于（int i=0；i<5；i++）{
试一试{
System.out.println（“我睡觉”）；
睡眠（1000）；
}捕捉（中断异常e）{
e、 printStackTrace（）；
}
}
flag=true；
System.out.println（“唤醒”）；
通知（）；
}
}
}

您可以使用一种简单的锁定方法：

public static void main (String[] args)
{
    // create new lock object
    Object lock = new Object();
    // create and start thread
    Thread t = new Thread(() ->
    {
        // try to sleep 1 sec
        try { Thread.sleep(1000); }
        catch (InterruptedException e) { /* do something */ }
        // notify main thread
        synchronized (lock) { lock.notifyAll(); }
    };
    t.start();
    // wait for second thread to finish
    synchronized (lock)
    {
        while (t.isAlive())
            lock.wait();
    }
    // second thread finished
    System.out.println("second thread finished :)");
}

您可以根据Javadoc调用要等待的

线程

等待此线程死亡

或者，您可以使用

如有必要，等待计算完成，然后检索其结果

---

实现所需功能的最简单方法是使用

Thread.join（超时）

另外，不要在

线程

对象上使用

同步

、

等待

或

通知

。这将干扰

线程。join

实现。有关详细信息，请参阅

以下是您的主程序的外观：

public static void main(String[] args) {
    MyProcess t = new MyProcess();
    t.start();

    try {
        t.join(10000L);
    } catch (InterruptedException ie) {
        System.out.println("interrupted");
    }

    System.out.println("Main thread resumes");
}

请注意，当主线程在调用

join（）

后恢复时，它无法判断子线程是否已完成或调用是否超时。要测试这一点，请调用

t.isAlive（）

当然，您的子线程可以做任何事情，但重要的是它不能在自身上使用

synchronized

、

wait

或

notify

。例如，这里有一个避免使用这些调用的重写：

class MyProcess extends Thread {
    public void run() {
        System.out.println("MyProcess starts");
        for (int i = 0; i < 5; i++) {
            try {
                System.out.println("MyProcess sleeps");
                sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("MyProcess finishes");
    }
}

类MyProcess扩展线程{
公开募捐{
System.out.println（“MyProcess启动”）；
对于（int i=0；i<5；i++）{
试一试{
System.out.println（“MyProcess休眠”）；
睡眠（1000）；
}捕捉（中断异常e）{
e、 printStackTrace（）；
}
}
System.out.println（“MyProcess Finishs”）；
}
}

class MyProcess extends Thread {
    public void run() {
        System.out.println("MyProcess starts");
        for (int i = 0; i < 5; i++) {
            try {
                System.out.println("MyProcess sleeps");
                sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("MyProcess finishes");
    }
}