Question

public class CreateThreadRunnableExample implements Runnable {

    public void run() {

        for (int i = 0; i < 5; i++) {
            System.out.println("Child Thread : " + i);

            try {
                Thread.sleep(50);
            } catch (InterruptedException ie) {
                System.out.println("Child thread interrupted! " + ie);
            }
        }

        System.out.println("Child thread finished!");
    }

    public static void main(String[] args) {

        Thread t = new Thread(new CreateThreadRunnableExample(), "My Thread");

        t.start();

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

            System.out.println("Main thread : " + i);

            try {
                Thread.sleep(100);
            } catch (InterruptedException ie) {
                System.out.println("Child thread interrupted! " + ie);
            }
        }
        System.out.println("Main thread finished!");
    }
}

在这个程序中两个睡眠方法都使用了不同的时间.. ,,,所以如果主线程运行时间那么子线程必须运行2次。但它只运行一次....它我们采取的概念runnable或running state ....然后当主线程结束时，那么2个子线程将处于就绪状态，那么为什么只有一个子线程运行。

Answer 1

首先，您添加了System.out.println（＆＃34; Child线程中断！＆＃34; + ie）;对于主线程和子线程，这是一个错字......

试试这个......两个线程都在运行（Main和Child线程）

该程序的主要方法放在JVM创建的主线程的底部，并且 Main方法创建另一个运行时堆栈并将子线程放入其中。

public class DemoThread implements Runnable {

    public void run() {

        for (int i = 0; i < 3; i++) {
            System.out.println("Child Thread ");

            try {
                Thread.sleep(200);
            } catch (InterruptedException ie) {
                System.out.println("Child thread interrupted! " + ie);
            }
        }

        System.out.println("Child thread finished!");
    }

    public static void main(String[] args) {

        Thread t = new Thread(new DemoThread ());

        t.start();

        for (int i = 0; i < 3; i++) {

            System.out.println("Main thread);

            try {
                Thread.sleep(200);
            } catch (InterruptedException ie) {
                System.out.println("Child thread interrupted! " + ie);
            }
        }
        System.out.println("Main thread finished!");
    }
}

Answer 2

sleep方法不是100％准确的时间，如JavaDoc中所述：

public static void sleep（long millis）                     抛出InterruptedException

导致当前正在执行的线程休眠（暂时停止执行）   指定的毫秒数，取决于精度和   系统定时器和调度程序的准确性。线程不会丢失   任何监视器的所有权。

基本上，代码有时可能会按预期工作，有时则不会。

另外，你似乎只开始一个孩子，所以你为什么期待2？

编辑：理论上是的，子线程应该执行两次，而main线程睡着了。话虽如此，正如JavaDoc中所解释的，sleep方法执行的准确性取决于它运行的系统，因此有时您可能会按预期工作，有时则不能。因此，举例来说，您可能会遇到main线程睡眠的情况，例如97毫秒而不是100，而孩子则睡眠时间为53毫秒。这将导致孩子只执行一次。

另一个选择是做这样的事情： while (currentTime <= timeNeededToElapse) { currentTime=... }。这导致了一个紧密的while循环，可以提供更好的控制，但据我所知，它仍然是100％准确，更不用说你将消耗CPU周期来有效地做任何事情，所以要谨慎使用。

Answer 3

你只开始一个子线程，所以你为什么期待两个？

关于超时，睡眠时间不准确，因此当一个线程睡眠100毫秒时，另一个线程可能会或可能不会睡眠两次50毫秒。这是race condition的典型示例。如果多次运行示例代码，在某些情况下可能会看到两个子线程消息，在其他情况下可能会看到一个。

Answer 4

尝试

  public class Test implements Runnable{

        public void run() {

            for (int i = 0; i < 5; i++) {
                System.out.println("CHILD THREAD : " + i);

                try {
                    Thread.sleep(50);
                } catch (InterruptedException ie) {
                    System.out.println("CHILD THREAD INTERRUPTED! " + ie);
                }
            }

            System.out.println("CHILD THREAD FINISHED!");
        }

        public static void main(String[] args) {

            Thread t = new Thread(new Test());

            t.start();

            for (int i = 0; i < 5; i++) {
                System.out.println("MAIN THREAD : " + i);
                try {
                    Thread.sleep(200);
                } catch (InterruptedException ie) {
                    System.out.println("CHILD THREAD INTERRUPTED! " + ie);
                }
            }
            System.out.println("MAIN THREAD FINISHED!");
        }
    }

可运行的接口示例

4 个答案: