Question

我正在通过＆＃34; Java教程＆＃34; Oracle发布了哪些内容，我不确定为什么我无法从＆＃34; Concurrency＆＃34;中获取此示例中的条件语句。要执行的章节：

if ((System.currentTimeMillis() - startTime > patience) &&
                msgThread.isAlive())

startTime变量在此上面初始化为：

long startTime = System.currentTimeMillis();

耐心变量可以是硬编码值（1小时），也可以是作为命令行参数传入的值（以秒为单位）。

    long patience = 1000 * 60 * 60; // initially 1 hour of patience

    // if there is a command-line arg
    if (args.length > 0) {
        try {
            // takes command-line arg as seconds
            patience = Long.parseLong(args[0]) * 1000;
        }
        catch (NumberFormatException e) {
            System.err.println("Invalid commmand-line argument, " +
                "terminating...");
            System.exit(1);
        }
    }

问题是，当我使用各种命令行参数运行程序时（即使我传入1，它应该在1秒后结束，我的响应没有任何区别！），它们都没有真正得到条件语句为true，然后中断msgThread并将消息打印到屏幕：

        // if the amount of time passed is more than patience and the
        // thread is still alive
        if ((System.currentTimeMillis() - startTime > patience) &&
            msgThread.isAlive()) {

            // "tired of waiting" to threadMessage
            threadMessage("Tired of waiting, ending thread.");
            // interrupt the thread
            msgThread.interrupt();
            // wait indefinitely for it to finish
            msgThread.join();
        }

以下是使用1秒命令行参数运行时控制台输出的示例：

以下是代码的完整副本，非常感谢理解这些结果的任何帮助！

/*
*   This program is from Chapter 13 of "The Java Tutorial". It demonstrates
*   some basic Thread funtionality by displaying 4 different messages
*   4 seconds apart in one Thread, while the other thread periodically
*   checks the total run time of the application to see if it has passed
*   a patience threshold, which is hard-coded as 1 hour but can be 
*   input by the user as a commmand-line arg in seconds. If the patience
*   threshold is reached, the main thread interrupts the message thread
*   and displays "finally!"
*/

public class SimpleThreads {
    /* 
    *  Display a message preceded by the name of the current thread.
    *  This will be called periodically throughout the program to
    *  show where we are in the app
    */
    public static void threadMessage(String message) {
        String threadName = Thread.currentThread().getName();
        System.out.format("%s: %s%n", threadName, message);
    }

    /*
    *   Private nested class that will be the Runnable object. The
    *   run() method will be called when a Thread starts execution.
    */
    private static class MessageLoop implements Runnable {
        /*
        *   Prints a message to the console every four seconds.
        *   There are 4 messages total. If interrupted, says so!.
        */
        @Override
        public void run() {
            String[] message = {"msg1", "msg2", "msg3", "msg4"};
            try {
                for (int i = 0; i < message.length; i++) {
                    Thread.sleep(4000); // throws exception if interrupted
                    threadMessage(message[i]);
                }
            }
            catch (InterruptedException e) {
                threadMessage("I wasn't done!");
            }
        }
    }

    /*
    *   Gets the amount of time (patience) that the user will wait for the
    *   MessageLoop classes thread to complete. Starts the MessageLoop
    *   Thread and tracks the total time it runs. If it runs more than
    *   the patience allows for, the MessageLoop thread will be 
    *   interrupted.
    */
    public static void main(String[] args) throws InterruptedException {

        long patience = 1000 * 60 * 60; // initially 1 hour of patience

        // if there is a command-line arg
        if (args.length > 0) {
            try {
                // takes command-line arg as seconds
                patience = Long.parseLong(args[0]) * 1000;
            }
            catch (NumberFormatException e) {
                System.err.println("Invalid commmand-line argument, " +
                    "terminating...");
                System.exit(1);
            }
        }

        // pass message "Starting MessageLoop thread" to threadMessage
        threadMessage("Starting MessageLoop");
        // get the currentTimeMillis and set as start time (long)
        long startTime = System.currentTimeMillis();

        // create a new Thread and pass it the MessageLoop runnable
        Thread msgThread = new Thread(new MessageLoop());
        // start the thread
        msgThread.start();

        // pass "Waiting for msglp thread to finish" to threadMessage
        threadMessage("Waiting for MessageLoop to finish...");

        // in a loop determined by if the thread is still alive
        while (msgThread.isAlive())

            // wait a max of 1 second for thread to finish
            msgThread.join(1000);

            // if the amount of time passed is more than patience and the
            // thread is still alive
            if ((System.currentTimeMillis() - startTime > patience) &&
                msgThread.isAlive()) {

                // "tired of waiting" to threadMessage
                threadMessage("Tired of waiting, ending thread.");
                // interrupt the thread
                msgThread.interrupt();
                // wait indefinitely for it to finish
                msgThread.join();
            }

        // "finally" to threadMessage
        threadMessage("Finally!");
    }
}

Answer 1

   while (msgThread.isAlive()) msgThread.join(1000);

你可能忘记输入{after while。现在你要等到线程完成，无论如何。

尝试：

    // in a loop determined by if the thread is still alive
    while (msgThread.isAlive()) {

        // wait a max of 1 second for thread to finish
        msgThread.join(1000);

        // if the amount of time passed is more than patience and the
        // thread is still alive
        if ((System.currentTimeMillis() - startTime > patience) &&
            msgThread.isAlive()) {

            // "tired of waiting" to threadMessage
            threadMessage("Tired of waiting, ending thread.");
            // interrupt the thread
            msgThread.interrupt();
            // wait indefinitely for it to finish
            msgThread.join();
        }
    }

为什么这个条件语句永远不会执行？

1 个答案: