Question

使用此方法

template<Context C>
struct context;

template<NAMESPACE_1> struct context<> {
  static foo_return_t foo(...) {
    return namespace1::foo (...);
  }
  static bar_return_t bar(...) {
    return namespace1::bar (...);
  }
};

template<NAMESPACE_2> struct context<> {
  static foo_return_t foo(...) {
    return namespace2::foo (...);
  }
  static bar_return_t bar(...) {
    return namespace2::bar (...);
  }
};

在实际完成外部未来之前，是否有可能等待嵌套的未来完成？这就是我执行这个程序的方式：

foo_ret_t a;
bar_ret_t b; 

if (choice == "namespace1") {
  a = context<NAMESPACE_1>::foo(...);
  b = context<NAMESPACE_1>::bar(...);
} else if (choice == "namespace1") {
  a = context<NAMESPACE_2>::foo(...);
  b = context<NAMESPACE_2>::bar(...);
}

这是我的控制台输出：

def taskA(): Future[Unit] = Future {
Future {
  print("Starting nested future")
  Thread.sleep(3000)
  print("Finished nested future")
} 
print("starting outer future")
Thread.sleep(1000)
print("finished outer future")
}

Answer 1

如果您想something 然后执行somethingElse，那么您将按顺序执行两个操作，其中第二个操作必须等到第一个操作完成。出于所有实际目的，这正是 monadic flatMap 所做的。所以，你应该做这样的事情：

def taskA(): Future[Unit] = for {
  _ <- Future {
    print("Starting first future")
    Thread.sleep(3000)
    print("Finished first future")
  };
  _ <- Future {
    print("starting outer future")
    Thread.sleep(1000)
    print("finished outer future")
  }
} yield ()

第一个_ <- ...将确保第一个未来在第二个未来开始之前终止。

返回包含预期完成的嵌套future的Future [Unit]的方法

1 个答案: