如何从另一个方法中断目标方法？并实现两方法并发执行

嘿，这个问题我之前做并发任务的时候也踩过坑，核心就是要打破同步调用的阻塞逻辑，换成并发执行的模式，同时还要处理好方法间的中断信号传递，咱们一步步来捋清楚：

你说得没错，普通的方法调用是同步栈执行的，调用方必须等被调用方法执行完出栈才能继续。要让foo()和bar()同时跑，最直接的方式是把其中一个（或者两个）方法放到独立的执行单元里——比如线程或者协程，这样它们就能各自独立调度，不用互相等待。

举两个常见语言的实现例子：

Java 示例（用线程实现并发） #

// 把bar的逻辑封装成可执行任务
Runnable barTask = () -> {
    // 定期检查中断标记，确保能响应中断
    while (!Thread.currentThread().isInterrupted()) {
        System.out.println("Bar is running...");
        try {
            // 模拟bar的业务耗时
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            // 捕获中断信号，做收尾工作
            System.out.println("Bar received interrupt signal, stopping...");
            // 重新设置中断标记，避免后续逻辑忽略中断
            Thread.currentThread().interrupt();
            break;
        }
    }
};

public void foo() {
    // 启动bar的独立线程
    Thread barThread = new Thread(barTask);
    barThread.start(); // 这里启动后，foo直接继续执行，不用等bar返回

    // foo自己的循环逻辑
    for (int i = 0; i < 5; i++) {
        System.out.println("Foo is running...");
        try {
            Thread.sleep(800);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    // 当foo需要中断bar时，发送中断信号
    barThread.interrupt();
    System.out.println("Foo asked bar to stop.");
}

Python 示例（用线程+Event做中断信号） #

Python没有原生的线程中断机制，用threading.Event做中断信号更安全：

import threading
import time

def bar(stop_signal):
    # 定期检查中断信号
    while not stop_signal.is_set():
        print("Bar is running...")
        time.sleep(1)
    print("Bar was interrupted, cleaning up...")

def foo():
    # 创建一个中断信号对象
    stop_bar = threading.Event()
    # 启动bar的线程，把信号传进去
    bar_thread = threading.Thread(target=bar, args=(stop_bar,))
    bar_thread.start()

    # foo自己的业务循环
    for i in range(5):
        print("Foo is running...")
        time.sleep(0.8)
    
    # 发送中断信号给bar
    stop_bar.set()
    # 等待bar线程完成收尾工作
    bar_thread.join()
    print("Foo finished and stopped bar.")

核心思路是用共享的中断标记/信号，让两个并发执行的方法能互相感知到中断请求：

• 对于有原生线程中断机制的语言（比如Java、C#），可以直接用线程的中断标记，但要注意捕获中断异常并正确处理（比如重新设置标记，避免后续逻辑忽略）
• 对于没有原生中断的语言（比如Python），用自定义的信号对象（如Event）或者布尔标记更安全，避免暴力终止线程导致资源泄漏

如果需要双向中断（比如bar也能中断foo），只需要给双方都传递对应的中断信号就行。比如Java里给foo的线程也设置中断标记，Python里创建两个Event分别控制对方。

• 绝对不要用暴力终止线程的方式（比如Java废弃的stop()方法），这会导致资源未释放、数据不一致等问题
• 并发执行的方法里，要定期检查中断标记，这样才能及时响应中断请求（比如例子里的循环条件就是检查标记）
• 如果方法里有阻塞操作（比如sleep、IO等待），要确保这些操作能响应中断（比如Java的sleep()会抛出InterruptedException，Python的Event.wait()可以被唤醒）

内容的提问来源于stack exchange，提问作者NotAPro