标签: future

val works: Seq[Future[Seq[Future[String]]]] = ...

我将如何等待所有这些顶部和嵌套Futures完成？

我的第一个想法是：

val result1: Seq[Seq[Future[String]]] = Await.result(
  Future.sequence(works), Duration.Inf
)

val result2: Seq[String] =  Await.result(
  Future.sequence(result1.flatten), Duration.Inf
)

但我想它并不像它应有的那样高效。

在 Play 框架中，我将 Slick 与 MySQL 数据库一起使用，如何将查询结果（Future[Seq[SomeClass]]）转换为 Json 以在 jQuery Autocomplete 中进一步使用。我可以序列化SomeClass，但是我应该在哪里使用.map（或其他东西）？

补充：

模型：

   package models
    import play.api.libs.json._

    case class Equipment(id: Long, name: String,area: String,kiMin: Double,kiMax: Double,cosFiMin: Double,cosFiMax: Double){

    implicit val equipmentWrites = new Writes[Equipment] {
    def writes(equipment: Equipment) = Json.obj(
    "id" -> equipment.id,
    "name" -> equipment.name,
    "area" -> equipment.area,
    "kiMin" -> equipment.kiMin,
    "kiMax" -> equipment.kiMax,
    "cosFiMin" -> equipment.cosFiMin,
    "cosFiMax" -> equipment.cosFiMax
    )

//also tried this for Seq

 /* def writes(equipment: Equipment): JsValue …

当在for循环中使用std :: async和launch :: async时,我的代码在同一个线程中串行运行,就好像每个异步调用在启动之前等待前一个异步调用一样.在std :: async引用(std :: async)的注释中,如果std :: future未绑定到引用,则可以这样做,但我的代码不是这种情况.任何人都可以找出它为什么连续运行？

这是我的代码片段:

class __DownloadItem__ { //DownloadItem is just a "typedef shared_ptr<__DownloadItem__> DownloadItem"
    std::string buffer;
    time_t last_access;
 std::shared_future<std::string> future;
}

for(uint64_t start: chunksToDownload){
        DownloadItem cache = std::make_shared<__DownloadItem__>();
        cache->last_access = time(NULL);
        cache->future =
                std::async(std::launch::async, &FileIO::download, this, api,cache, cacheName, start, start + BLOCK_DOWNLOAD_SIZE - 1);
     }
}

未来将存储在共享的未来,因为多个线程可能正在等待同一个未来.

我也在使用GCC 6.2.1来编译它.

我有以下方法返回Play for Scala应用程序中的字符串列表:

def example = Action.async { request =>

  val access = getAccess()

  if (access > 0) {
          val future = MyObject.intensiveMethod
          future.map {
              result => {
                  val list = result.asInstanceOf[List[String]]
                  val json = JsObject(Seq(
                      "list" -> Json.toJson(list)
                  ))
                  Ok(json)
              }
          }
  }
  else {
      val json = JsObject(Seq(
          "msg" -> JsString("error!")
      ))
      Ok(json)
  }

}

代码不会编译时出现以下错误,因为如果access = 0,则结​​果不是Future:

类型不匹配; 发现:play.api.mvc.Result required:scala.concurrent.Future [play.api.mvc.Result]

如何解决这个问题？

我想弄清楚如何重新排队一些已超时的异步 DNS 请求（我正在使用 uvloop 和 aiodns 模块）。

这是我设置循环的代码：

asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
loop = asyncio.get_event_loop()
resolver = aiodns.DNSResolver(loop=loop)
sem = asyncio.Semaphore(MAX_COUNT)

此函数执行查找：

async def lookup(name):
    with (await sem):
        response = await resolver.query(name, 'A')
        return response

我读入了一个包含名称的文件以查找和设置任务，包括处理结果的回调：

for n in names:
    host = '{}.{}'.format(n, domain)
    task = asyncio.ensure_future(lookup(host))
    tasks.append(task)
    task.add_done_callback(functools.partial(got_result, host))

并启动查找队列。

print("Looking up {} subdomains...".format(len(names)))
loop.run_until_complete(asyncio.wait(tasks))
loop.close()

在got_result回调中，我然后测试 future.exception() 并处理它，如果有，如果没有，则将结果打印到屏幕上。我可以接受一些例外情况（即找不到域名），但其他人喜欢超时，我想重新排队项目。是否有一种简单的方法可以将未来添加回循环以进行另一次尝试，还是我需要为此设置单独的功能并手动重新添加任务？

谢谢你的帮助。

我有来自Tokio docs的以下工作代码,我稍微修改了一下:

// Task
let connection = io::read_exact(socket, buf_read)
    .and_then(|(socket, buf_read)| {
        println!("Do something with the received data...");
        for b in &buf_read {
            println!("{}", b);
        }

        // Write to the socket
        let buf_write = vec![19; 30];
        io::write_all(socket, buf_write)
    })
    .then(|res| {
        println!("{:?}", res); // Just for testing
        //Output: Ok((TcpStream, [19, 19, 19, ...]

        println!("Send data...");
        let buf_write = vec![18; 10]; // Fill the buffer with some data
        //
        //How to use the socket contained in res to write the data …

以下代码无法编译：

#include <iostream>
#include <future>
#include <vector>

class Calculator {
public:
    static int add(int a, int b)
    {
        return a + b;
    }
};

int main(int argc, char* argv[]) {
    std::vector<std::future<int>*> futures;

    for(auto i = 0; i < 4; i++) {
        auto future = new std::async(&Calculator::add, 1, 3);
        futures.push_back(future);
    }

    for(auto i = 0; i < 4; i++) {
        std::cout << futures[i]->get() << std::endl;
        delete futures[i];
    }

    return 0;
}

我收到以下错误：

error: no type named 'async' in namespace 'std'

如何在期货向量上存储和调用 …

我从服务器获取一个 int Id，它在颤振的 HTTP 请求中，这没问题，我想将此值保存在一个变量中，但是当我调用返回值时，我收到此错误实例 'Future' ，有什么建议吗？ ? 这是代码

                    child: RaisedButton(onPressed:() {
                    CurrentPrjId= SaveProject();
                    print("CurrentPrjId Is saved CurrentPrjId :::::::: " );
                    print(CurrentPrjId);
                    Navigator.of(context).pushReplacementNamed('/AllUSerStories');
                }
//Save Project

  Future SaveProject() async {

//SaveProjectResult has the id of the current created project which i need that for its user stories
var SaveProjectResult = await GetPostProjects().createProject(_ProjectnameController.text, _CustomernameController.text, _dropNewItem, _dropNewItem2, _StartDateController.text, _EndDateController.text,);
print(":::::::::::::::::::::::::::::::The Project Is Created And Here Its ID In SaveProject:::::::::");
print(SaveProjectResult);
return SaveProjectResult;

}

我一直试图理解为什么 Scala Futures 被认为是急切的并且违反了引用透明性。我想我理解这部分是合理的。但是，我无法理解这意味着什么：

(A => Unit) => Unit

关于未来。

我不确定这是否是正确的论坛，但感谢 ELI5 的回答

ExecutorService executor = Executors.newFixedThreadPool(2);

Future<Integer> calculate(Integer input) {
    return executor.submit(() -> {
        Thread.sleep(3000);
        return input * input;
    });
}

public static void main(String []args) throws Exception {
    Main m = new Main();
    System.out.println(m.calculate(5).get());
    System.out.println("Main");

我们使用 2 个线程将 Callable 提交给 Executor，但是当我告诉m.calculate(5).get()它阻塞主线程时。所以，我不明白，Future如果它阻塞主线程并且不异步运行，我什么时候以及为什么应该使用它？