java中线程之间的通信：如果另一个线程已完成，则停止该线程

我怎样才能让一个线程在另一个线程也在运行的情况下运行，也就是说，如果我从一个线程运行返回，那么我希望另一个线程也停止运行， 我的代码如下所示：

ClientMessageHandler clientMessagehandler = new ClientMessageHandler();
ServerMessageHandler serverMessagehandler = new ServerMessageHandler();
Thread thread1 = new Thread(serverMessagehandler);
Thread thread2 = new Thread(clientMessagehandler);
thread2.start();
thread1.start();

我想使

thread1

在

thread2

停止运行时停止运行

编辑：检测

thread2

何时停止运行以停止

thread1

运行，而不是如何停止

thread1

运行

---

感谢编辑澄清问题

我认为有两个直接的选择：

备选案文1。让ClientMessageHandler实现在ServerMessageHandler终止时终止它。这意味着客户端需要对服务器线程的引用

public class ClientMessageHandler implements Runnable {
    Thread serverThread;
    public ClientMessageHandler(Thread srvThread) {
        this.serverThread = srvThread;
    }
    public void run() {
        try {
            while (true) { ... }
        } finally {
           serverThread.interrupt();
        }
   }
}

备选案文2。使用

thread2.join（）

或a等待thread2终止。当控件从联接（或）返回时

---

确保在thread1的run方法中，您有一些逻辑位置可以检查中断状态（）并决定终止。此外，您必须注意正确处理并终止或重置中断标志。

编辑以澄清问题

我认为有两个直接的选择：

备选案文1。让ClientMessageHandler实现在ServerMessageHandler终止时终止它。这意味着客户端需要对服务器线程的引用

public class ClientMessageHandler implements Runnable {
    Thread serverThread;
    public ClientMessageHandler(Thread srvThread) {
        this.serverThread = srvThread;
    }
    public void run() {
        try {
            while (true) { ... }
        } finally {
           serverThread.interrupt();
        }
   }
}

备选案文2。使用

thread2.join（）

或a等待thread2终止。当控件从联接（或）返回时

---

确保在thread1的run方法中，您有一些逻辑位置可以检查中断状态（）并决定终止。此外，您必须注意正确处理并终止或重置中断标志。

只有当

run（）

方法返回时，

线程才会停止。请求中断的唯一信号。您仍然必须相应地在
run（）
方法中编写代码，以便它定期检查并相应地处理。例如，在
线程执行的每个任务单元上检查它，或者在连接了sort of progresslistener的每个特定进程上检查它。
只有当
run（）
方法返回时，
线程才会停止。请求中断的唯一信号。您仍然必须相应地在
run（）
方法中编写代码，以便它定期检查并相应地处理。例如，检查
线程正在执行的每一个任务单元，或连接排序progresslistener时的每一个特定进度。
这个最小的示例应该演示基本思想：

import java.io.*;
import java.util.concurrent.LinkedBlockingQueue;

public class Test {

    static LinkedBlockingQueue<String> msgBuf = new LinkedBlockingQueue<String>();
    static volatile boolean keepRunning = true;
    static Thread thread1, thread2;

    public static void main(String[] args) throws IOException {
        ClientMessageHandler clientMessagehandler = new ClientMessageHandler();
        ServerMessageHandler serverMessagehandler = new ServerMessageHandler();
        thread1 = new Thread(serverMessagehandler);
        thread2 = new Thread(clientMessagehandler);
        thread2.start();
        thread1.start();
    }

}

class ClientMessageHandler implements Runnable {
    public void run() {
        while (Test.keepRunning) {
            try {
                String msg = Test.msgBuf.take();
                System.out.println("Eating " + msg);
            } catch (InterruptedException ie) {
            }
        }
    }
}

class ServerMessageHandler implements Runnable {
    public void run() {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String in;
        try {
            while (!(in = br.readLine()).equals("quit")) {
                System.out.println("Feeding " + in);
                Test.msgBuf.offer(in);
            }
        } catch (IOException e) {
        }
        Test.keepRunning = false;
        Test.thread2.interrupt();
    }
}

import java.io.*；
导入java.util.concurrent.LinkedBlockingQueue；
公开课考试{
静态LinkedBlockingQueue msgBuf=新LinkedBlockingQueue（）；
静态可变布尔修剪=true；
静态螺纹螺纹1、螺纹2；
公共静态void main（字符串[]args）引发IOException{
ClientMessageHandler ClientMessageHandler=新的ClientMessageHandler（）；
ServerMessageHandler ServerMessageHandler=新的ServerMessageHandler（）；
thread1=新线程（serverMessagehandler）；
thread2=新线程（clientMessagehandler）；
thread2.start（）；
thread1.start（）；
}
}
类ClientMessageHandler实现Runnable{
公开募捐{
while（测试、继续修剪）{
试一试{
字符串msg=Test.msgBuf.take（）；
System.out.println（“吃”+味精）；
}捕获（中断异常ie）{
}
}
}
}
类ServerMessageHandler实现Runnable{
公开募捐{
BufferedReader br=新的BufferedReader（新的InputStreamReader（System.in））；
串入；
试一试{
而（！（in=br.readLine（））.equals（“退出”））{
系统输出打印项次（“进料”+in）；
Test.msgBuf.offer（in）；
}
}捕获（IOE异常）{
}
Test.keepRunning=false；
Test.thread2.interrupt（）；
}
}
这个最简单的例子应该说明以下基本思想：

import java.io.*;
import java.util.concurrent.LinkedBlockingQueue;

public class Test {

    static LinkedBlockingQueue<String> msgBuf = new LinkedBlockingQueue<String>();
    static volatile boolean keepRunning = true;
    static Thread thread1, thread2;

    public static void main(String[] args) throws IOException {
        ClientMessageHandler clientMessagehandler = new ClientMessageHandler();
        ServerMessageHandler serverMessagehandler = new ServerMessageHandler();
        thread1 = new Thread(serverMessagehandler);
        thread2 = new Thread(clientMessagehandler);
        thread2.start();
        thread1.start();
    }

}

class ClientMessageHandler implements Runnable {
    public void run() {
        while (Test.keepRunning) {
            try {
                String msg = Test.msgBuf.take();
                System.out.println("Eating " + msg);
            } catch (InterruptedException ie) {
            }
        }
    }
}

class ServerMessageHandler implements Runnable {
    public void run() {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String in;
        try {
            while (!(in = br.readLine()).equals("quit")) {
                System.out.println("Feeding " + in);
                Test.msgBuf.offer(in);
            }
        } catch (IOException e) {
        }
        Test.keepRunning = false;
        Test.thread2.interrupt();
    }
}

import java.io.*；
导入java.util.concurrent.LinkedBlockingQueue；
公开课考试{
静态LinkedBlockingQueue msgBuf=新LinkedBlockingQueue（）；
静态可变布尔修剪=true；
静态螺纹螺纹1、螺纹2；
公共静态void main（字符串[]args）引发IOException{
ClientMessageHandler ClientMessageHandler=新的ClientMessageHandler（）；
ServerMessageHandler ServerMessageHandler=新的ServerMessageHandler（）；
thread1=新线程（serverMessagehandler）；
thread2=新线程（clientMessagehandler）；
thread2.start（）；
thread1.start（）；
}
}
类ClientMessageHandler实现Runnable{
公开募捐{
while（测试、继续修剪）{
试一试{
字符串msg=Test.msgBuf.take（）；
System.out.println（“吃”+味精）；
}捕获（中断异常ie）{
}
}
}
}
类ServerMessageHandler实现Runnable{
公开募捐{
BufferedReader br=新的BufferedReader（新的InputStreamReader（System.in））；
串入；
试一试{
而（！（in=br.readLine（））.equals（“退出”））{
系统输出打印项次（“进料”+in）；
Test.msgBuf.offer（in）；
}
}捕获（IOE异常）{
}
Test.keepRunning=false；
Test.thread2.interrupt（）；
}
}
它不会立即停止。。。是的，很好，以后再编辑。@BalusC是的，我知道，我正在尝试Tom Hawtin在博客上写的东西。我的意思是，检测thread2何时停止运行以阻止thread1运行，而不是如何阻止thread1运行running@Noona，我做了一些繁重的编辑以弥补您的澄清。aIt不会立即停止。。。