我正在研究Oracle发布的“ The Java Tutorial”，但不确定为什么无法从“ Concurrency”一章中获取此示例中的条件语句来执行：
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!");
}
}
最佳答案
while (msgThread.isAlive()) msgThread.join(1000);
您可能忘记了输入{。
现在您正在等待线程完成，无论如何。
尝试：
// 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();
}
}