Question

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

“主”线程必须等待辅助线程几秒钟才能完成该过程，在此之后，无论副线程进程发生什么，“主”线程都必须重新启动。

如果辅助流程先前结束，则“主”线程必须重新开始工作。

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

我在这里有一个代码，但是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");
        }
    }
}

}

public class MyProcess extends Thread {

public void run() {
    System.out.println("start");

    synchronized (this) {
        for (int i = 0; i < 5; i++) {

            try {
                System.out.println("I sleep");
                sleep(1000);

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        flag = true;
        System.out.println("Wake up");
        notify();
    }

}
}

Answer 1

实现目标的最简单方法是使用Thread.join(timeout)。

此外，不在synchronized个对象上使用wait，notify或Thread。这将干扰Thread.join实施。有关详细信息，请参阅documentation。

这是你的主程序的样子：

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");
    }
}

Answer 2

您可以使用简单的锁定方法执行此操作：

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 :)");
}

Answer 3

根据Javadoc，你可以在你想要等待的Thread上调用Thread.join()，

等待此线程死亡。

或者，您可以使用Future，然后只需拨打get()即可。 Javadoc中，

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

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

3 个答案: