Java 可通过while循环调用

我需要提供代码，使用ExecutorService、Callable和Future将进行一些计算并打印部分结果，直到达到定义的条件。我想到的第一件事是使用while循环。不幸的是，据我所知，ExecutorService.get（）会等待任务完成，因此我无法执行类似（伪代码）的操作：

---

有人能告诉我应该朝哪个方向走吗？

脏选项是在while循环中放置一个

System.out.println

cleaner选项将是发布/订阅模式，如：

interface Subscriber {
    void onPartialResult(double partialResult);
}
class SystemOutSubscriber implements Subscriber{
    @Override
    void onPartialResult(double partialResult) {
        System.out.println(partialResult);
    }
}
class YourCalculatorClass {
    List<Subscriber> subscribers = ...
    public Object call() throws Exception {
       while(!condition) {
          //perform calc
          for(Subscriber s : subscribers) {
              s.onPartialResult(partialCalculationResult);
           }
        }
     }
}

接口订户{
无效部分结果（双重部分结果）；
}
类SystemOutSubscriber实现订阅服务器{
@凌驾
void onPartialResult（双重partialResult）{
系统输出打印项次（部分结果）；
}
}
给你的计算器上课{
列表订阅者=。。。
公共对象调用（）引发异常{
而（！条件）{
//进行计算
用于（订户s：订户）{
s、 部分结果（部分计算结果）；
}
}
}
}

脏选项将

System.out.println

放入while循环中

cleaner选项将是发布/订阅模式，如：

interface Subscriber {
    void onPartialResult(double partialResult);
}
class SystemOutSubscriber implements Subscriber{
    @Override
    void onPartialResult(double partialResult) {
        System.out.println(partialResult);
    }
}
class YourCalculatorClass {
    List<Subscriber> subscribers = ...
    public Object call() throws Exception {
       while(!condition) {
          //perform calc
          for(Subscriber s : subscribers) {
              s.onPartialResult(partialCalculationResult);
           }
        }
     }
}

接口订户{
无效部分结果（双重部分结果）；
}
类SystemOutSubscriber实现订阅服务器{
@凌驾
void onPartialResult（双重partialResult）{
系统输出打印项次（部分结果）；
}
}
给你的计算器上课{
列表订阅者=。。。
公共对象调用（）引发异常{
而（！条件）{
//进行计算
用于（订户s：订户）{
s、 部分结果（部分计算结果）；
}
}
}
}

此处：

while(!condition) {
  //perform calc
  return partialCalculationResult;
}

表示逻辑中存在“漏洞”。这应该是这样的：

while(!condition) {
  // perform computation
  push intermediate results somewhere
}
return finalResult;

换句话说：您在这里谈论的是两个不同的元素。对于那些“进展”更新，您将需要某种共享数据结构；例如，队列

您可以看到，与其他语言不同的是，没有内置的“生成器”概念允许您从循环中生成值；例如，您可以在或中执行此操作。

此处：

while(!condition) {
  //perform calc
  return partialCalculationResult;
}

表示逻辑中存在“漏洞”。这应该是这样的：

while(!condition) {
  // perform computation
  push intermediate results somewhere
}
return finalResult;

换句话说：您在这里谈论的是两个不同的元素。对于那些“进展”更新，您将需要某种共享数据结构；例如，队列

---

您可以看到，与其他语言不同的是，没有内置的“生成器”概念允许您从循环中生成值；类似于您可以在或中执行的操作。

您可以使用Thread.interrupt在while循环中停止线程，并将剩余结果添加到列表中

while（！condition）{list.add（addResultHere） Thread.interrupt（）；}

---

您可以使用Thread.interrupt在while循环中停止线程，并将剩余结果添加到列表中

while（！condition）{list.add（addResultHere） Thread.interrupt（）；}

---

下面是使用

ExecutorService

推送可调用的任务。为了便于示例，我现在将它们推到while循环中，但是它们可以来自任何地方。callable本身使用了一个最愚蠢的简单例子，当然，它需要一个数字。如果数字小于5，则一切正常，我们返回一条文本。如果没有，我们什么也不退还。当对未来进行评估且结果为空时，我们关闭ExecutorService并将其终止。因此，这是一个使用

ExecutorService

、

Callable

和

Future

来做一些至少与我从您的解释中可以看出的类似的事情的示例

public ExecutorServiceTest() {
    ExecutorService service = Executors.newCachedThreadPool();
    int num = 0;
    while (true) {
        Future<Optional<String>> future = service.submit(new MyCallable(num++));

        try {
            Optional<String> result = future.get();
            if (!result.isPresent()) {
                service.shutdown();
                break;
            }
            System.out.println(result.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
            service.shutdown();
        }
    }
}

private static class MyCallable implements Callable<Optional<String>> {
    private final int num;

    MyCallable(int num) {
        this.num = num;
    }

    @Override
    public Optional<String> call() throws Exception {
        if (num < 5)
            return Optional.of("My number is " + num);
        return Optional.empty();
    }
}

public static void main(String[] args) {

    new ExecutorServiceTest();
}

公共执行器服务测试（）{
ExecutorService=Executors.newCachedThreadPool（）；
int num=0；
while（true）{
Future=service.submit（新的MyCallable（num++））；
试一试{
可选结果=future.get（）；
如果（！result.isPresent（））{
service.shutdown（）；
打破
}
System.out.println（result.get（））；
}捕获（中断异常|执行异常e）{
e、 printStackTrace（）；
service.shutdown（）；
}
}
}
私有静态类MyCallable实现了Callable{
私有最终整数；
MyCallable（int num）{
this.num=num；
}
@凌驾
公共可选调用（）引发异常{
if（num<5）
返回可选的.of（“我的号码是”+num）；
返回可选的.empty（）；
}
}
公共静态void main（字符串[]args）{
新的ExecutorServiceTest（）；
}

下面是一个使用执行器服务的小例子 推送可调用的任务。为了便于示例，我现在将它们推到while循环中，但是它们可以来自任何地方。callable本身使用了一个最愚蠢的简单例子，当然，它需要一个数字。如果数字小于5，则一切正常，我们返回一条文本。如果没有，我们什么也不退还。当对未来进行评估且结果为空时，我们关闭ExecutorService并将其终止。因此，这是一个使用

ExecutorService

、

Callable

和

Future

来做一些至少与我从您的解释中可以看出的类似的事情的示例

public ExecutorServiceTest() {
    ExecutorService service = Executors.newCachedThreadPool();
    int num = 0;
    while (true) {
        Future<Optional<String>> future = service.submit(new MyCallable(num++));

        try {
            Optional<String> result = future.get();
            if (!result.isPresent()) {
                service.shutdown();
                break;
            }
            System.out.println(result.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
            service.shutdown();
        }
    }
}

private static class MyCallable implements Callable<Optional<String>> {
    private final int num;

    MyCallable(int num) {
        this.num = num;
    }

    @Override
    public Optional<String> call() throws Exception {
        if (num < 5)
            return Optional.of("My number is " + num);
        return Optional.empty();
    }
}

public static void main(String[] args) {

    new ExecutorServiceTest();
}

公共执行器服务测试（）{
ExecutorService=Executors.newCachedThreadPool（）；
int num=0；
while（true）{
Future=service.submit（新的MyCallable（num++））；
试一试{
可选结果=future.get（）；
如果（！result.isPresent（））{
service.shutdown（）；
打破
}
System.out.println（result.get（））；
}捕获（中断异常|执行异常e）{
e、 普林斯塔克特