java - 如何从一个方法中中断另一个方法？

Question

我希望能够同时运行两种方法。

public void bar(){
    //Do some stuff which has a result
    //If result is true, then stop foo().
}

public void foo()
{
    for (int x = 0; x <= 100; ++x)
    {
        //Do some stuff...
        //Execute bar, but don't wait for it to finish before jumping to next iteration.
    }
}

按照我的理解，当一个方法被调用时，它被放入堆栈中，然后当该方法完成时，它从堆栈中返回，然后程序将从调用该方法的地方继续执行。

因此，如果 foo() 在循环期间调用 bar()，它将等到 bar() 返回后再继续循环。

但是，我想要发生的是，当 foo 执行 bar 时，它不会等到 bar 执行完毕才继续迭代；它只是通知 bar() 应该运行，然后继续循环。

类似于线程中的run将运行该方法然后返回它，但是start将在新的线程中启动run方法线程，并且 start 方法立即返回，允许运行下一行代码。

此外，每次运行 bar() 时，根据结果，我希望它中断 foo()，无论当前正在执行哪一行 foo() 。我不想在 foo() 方法中检查 bar() 的结果，但我想要这样的功能:当 foo() 正在执行时，它会被 bar() 的执行中断。

希望让这个更容易理解:假设我有两个人执行任务 A 和 B。A 是 foo，B 是 bar。

A 将执行他的任务 100 次，但每次执行任务后，他都会告诉 B 执行其各自的任务(在每次迭代结束时调用 bar())，然后继续执行下一个任务任务。

B 完成任务的时间比 A 完成任务的时间短，因此当 B 完成任务时，A 仍会执行他的任务，并且根据 B 任务的结果，他将执行他的任务。可能会告诉 A 停止执行他的任务。

Answer 1

however I don't want to create a new Thread every time to do a new iteration of bar().

您可以实现Thread Pool这将为您处理线程，因此您的程序不会继续为 B 任务生成新线程 - 它会获取工作线程。值得考虑

顺便说一句:How to stop a thread from another thread?应该给你一个关于如何管理线程中断的提示

编辑:您可以get active Threads references by name .

Thread getThreadByName(String name) {
    // Get current Thread Group
    ThreadGroup threadGroup = Thread.currentThread().getThreadGroup();
    ThreadGroup parentThreadGroup;
    while ((parentThreadGroup = threadGroup.getParent()) != null) {
        threadGroup = parentThreadGroup;
    }
    // List all active Threads
    final ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
    int nAllocated = threadMXBean.getThreadCount();
    int n = 0;
    Thread[] threads;
    do {
        nAllocated *= 2;
        threads = new Thread[nAllocated];
        n = threadGroup.enumerate(threads, true);
    } while (n == nAllocated);
    threads = Arrays.copyOf(threads, n);
    // Get Thread by name
    for (Thread thread : threads) {
        System.out.println(thread.getName());
        if (thread.getName().equals(name)) {
            return thread;
        }
    }
    return null;
}

并从任何你想要的地方中断正在运行的线程。请记住，这是一个非常花哨的解决方案，我建议您重新考虑您的并发架构。这篇文章中有很多很好的解决方案 - 尝试一下。

void foo() {
    Thread fooThread = new Thread(new Runnable() {
        @Override
        public void run() {
            for (int i = 0; i < 5; i++) {
                try {
                    bar(); // Spawns barThread, but continues execution
                    Thread.sleep(2000); // foo has to return after bar, else NullPointerException is thrown
                } catch (InterruptedException e) {
                    //handle interruption
                }
            }
        }
    }, "fooThread"); // here im assigning name to fooThread
    fooThread.start();
}

void bar() {
    Thread barThread = new Thread(new Runnable() {
        @Override
        public void run() {
            // do something that interrupts foo()
            getThreadByName("fooThread").interrupt();
        }
    });

    barThread.start();
}