Question

我的JAVA代码正在创建扩展线程类的类

   public static void main(String[] args)
    {
    MyThread ct=new MyThread();
    Thread t=new Thread(ct);
    t.start();
    System.out.println(5);
    }

    public class MyThread extends Thread {
    public void run()
        {
            for(int i=1;i<=10;i++)
            {  System.out.println("abc");
                if (i==5)
                    //do something


            }

输出应为：- abc abc abc abc 5 abc abc abc abc

Answer 1

Java线程根本没有没有挂起/恢复（顺便说一句，您甚至不能强制杀死）。您不能指向某个任意线程并指示其“停止执行”其当前正在执行的操作。

含义：当您想要这样的功能时，您必须自己实现。正如评论所建议的那样，您可以使用wait/notify。或其他类型的锁定机制。

其他解决方案将使用类似数据结构的 queue 。父级将“命令对象”推送到该队列中，而子线程会定期检查队列中是否有新命令，并根据收到的命令进行调整。

此处的要点：您的代码必须实现某种协议，该协议允许一个线程对另一个线程进行控制。

除此之外，您还必须了解，启动子线程后，父线程仅靠自己前进即可。在您的示例中，父级和子级之间没有没有同步，因此“ 5”可以出现在任意随机时间点。

Answer 2

要获得所需的输出，不仅需要在i == 5时暂停子线程，还需要暂停主线程，直到子线程打印前五个abc。

您可以在子线程和主线程之间使用两个CountDownLatch进行通信：

import java.util.concurrent.CountDownLatch;

public class Main {


    static class Child implements Runnable {

        CountDownLatch waitLatch;
        CountDownLatch notifyLatch;

        public Child(CountDownLatch waitLatch, CountDownLatch notifyLatch) {
            this.waitLatch = waitLatch;
            this.notifyLatch = notifyLatch;
        }

        @Override
        public void run() {
            for (int i = 1; i <= 10; i++) {
                System.out.println("abc");
                if (i == 5) {
                    try {
                        notifyLatch.countDown(); // signal main thread, let it print number 5
                        waitLatch.await(); // wait for the signal from main thread
                    } catch (InterruptedException e) {

                    }
                }
            }
        }
    }

    public static void main(String[] args) {

        CountDownLatch waitLatch = new CountDownLatch(1);
        CountDownLatch notifyLatch = new CountDownLatch(1);

        Runnable child = new Child(waitLatch, notifyLatch);
        new Thread(child).start();

        try {
            notifyLatch.await(); // wait for the signal from child thread
        } catch (InterruptedException ignore) {

        }
        System.out.println(5);
        waitLatch.countDown(); // resume child thread
    }
}

是否可以先挂起子线程然后回调父线程，然后再次恢复子线程

2 个答案: