线程程序对连接的混淆答案

【问题标题】：Thread program confusion over join线程程序对连接的混淆
【发布时间】：2014-08-01 10:33:10
【问题描述】：

我正在阅读有关 Threads 的 Oracle 教程。我发现下面的程序有点混乱。根据我的说法，join 方法用于线程等待当前线程完成执行。为什么他们调用 t.join(1000) 是这让主线程等待？为什么他们在调用 t.interrupt() 后必须 t.join

public class SimpleThreads {

    // Display a message, preceded by
    // the name of the current thread
    static void threadMessage(String message) {
        String threadName =
            Thread.currentThread().getName();
        System.out.format("%s: %s%n",
                          threadName,
                          message);
    }

    private static class MessageLoop
        implements Runnable {
        public void run() {
            String importantInfo[] = {
                "Mares eat oats",
                "Does eat oats",
                "Little lambs eat ivy",
                "A kid will eat ivy too"
            };
            try {
                for (int i = 0;
                     i < importantInfo.length;
                     i++) {
                    // Pause for 4 seconds
                    Thread.sleep(4000);
                    // Print a message
                    threadMessage(importantInfo[i]);
                }
            } catch (InterruptedException e) {
                threadMessage("I wasn't done!");
            }
        }
    }

    public static void main(String args[])
        throws InterruptedException {

        // Delay, in milliseconds before
        // we interrupt MessageLoop
        // thread (default one hour).
        long patience = 1000 * 60 * 60;

        // If command line argument
        // present, gives patience
        // in seconds.
        if (args.length > 0) {
            try {
                patience = Long.parseLong(args[0]) * 1000;
            } catch (NumberFormatException e) {
                System.err.println("Argument must be an integer.");
                System.exit(1);
            }
        }

        threadMessage("Starting MessageLoop thread");
        long startTime = System.currentTimeMillis();
        Thread t = new Thread(new MessageLoop());
        t.start();

        threadMessage("Waiting for MessageLoop thread to finish");
        // loop until MessageLoop
        // thread exits
        while (t.isAlive()) {
            threadMessage("Still waiting...");
            // Wait maximum of 1 second
            // for MessageLoop thread
            // to finish.
            t.join(1000);
            if (((System.currentTimeMillis() - startTime) > patience)
                  && t.isAlive()) {
                threadMessage("Tired of waiting!");
                t.interrupt();
                // Shouldn't be long now
                // -- wait indefinitely
                t.join();
            }
        }
        threadMessage("Finally!");
    }
}

【问题讨论】：

当您打断威胁时，不一定会退出。因此，您添加一个连接只是为了确保 while (t.isAlive()) 为 FALSE 并且您可以退出循环。

标签： java multithreading

【解决方案1】：

他们正在调用中断来停止线程正在处理的当前函数，然后加入来告诉线程等待。

你可能会觉得这篇文章很有帮助

What does this thread join code mean? [closed]

以及下面关于并发的文章

Interrupts

Joins

【讨论】：