我有一个私有的Stack S,它填充了来自类外的对象(使用方法).ListenableFuture应该读取堆栈并从中检索一个Object,但如果堆栈为空,它应该等待一个对象插入堆栈然后检索它.我不确定如何实现这一点.
我的想法是使用Wait/Notify作为ListenableFuture,但这是正确的逻辑(与Guava合作)？我还有其他选择吗？
提前谢谢,盖伊
我已经阅读了Reactive Manifesto几次,并试图绕过所有这些反应性,异步,无阻塞的东西.很清楚如何在Actors之上构建可扩展系统,但是如果我会Future在我的代码中主动使用scala,那么我将在可扩展性,异步执行执行方面获得相同的效果,每个方法都会接受或返回Future.这种服务是否具有可扩展性和响应性？让我们说在这个问题中,我对事件驱动和弹性部分服务并不感兴趣.
我想知道Futures是否更适合与Actors一起使用,而不是在不使用Actor的程序中.换句话说,正在进行异步计算,以及将来最好在Actors系统中完成的事情吗？
这就是我说的原因:
1 - 您执行计算,结果将触发您可能在另一个线程中执行的某些操作.
例如,我有一个很长的操作来确定某些东西的价格,从我的主线程,我决定为它启动一个异步过程.与此同时,我可以做其他事情,然后当响应准备好/可用或传回给我时,我继续前进.
我可以看到使用actor这很方便,因为你可以将结果传递给一个actor.但是使用典型的线程模型,你可以阻止或....
2 - 另一个问题,就是说我需要通过在线获取一些信息来更新参与者列表的年龄.假设我只有一个未来的任务.关闭参与者列表是不是做错了.多个线程可能同时访问该参与者列表.所以在未来进行更新根本就是错误的,在那种情况下,我们需要java并发集合不是吗？
也许我认为这是错误的方式,未来根本不是要做副作用
但在这种情况下,公平,没有副作用,但我们仍然有从调用线程获取值的问题,这只能阻塞.我的意思是让我们想象一下,结果会帮助调用线程更新一些数据结构.如何在不以某种方式关闭该数据结构的情况下异步更新.
我相信像OnComplete这样的回调可以用于副作用(我在这儿吗？)
不过,无论如何,回调都必须关闭数据结构.因此,我不知道如何使用Actor.
PS:我喜欢演员,我只是想在没有演员的情况下更好地理解未来的用法.我到处读,只有在需要管理状态时才应该使用actor.在我看来,总的来说,使用future,没有actor,总是涉及阻塞某个地方,如果结果需要在某个时候传回给发起异步任务的线程.
我的标题可能没有描述我试图理解的问题代码:
这是一段代码:
def getMeConcurrentInputStream[A, I <: InputStream](in:I)(fn:I => A):Future[A] = {
future {
fn(in)
}andThen {
case all => in.close()
}
}
我试图了解该功能的用途.这是什么:
[A, I <: InputStream](in:I)(fn:I => A)
这是什么: (in:I)(fn:I => A)
而功能正在回归未来？我怎么解释:Future[A]
我如何解释以上所有内容？如何通过从代码中的其他位置调用它来使用此函数？
我试图通过以下方式从作为Future的函数返回一个元组：
def f:Future[(List[Int],List[String])] = Future{
(List(1,2,3),List("Hello","World"))
}
我从main打电话如下：
var (a,c) = f
这给了我以下错误
Error: constructor cannot be instantiated to expected type;
found : (T1, T2)
required: scala.concurrent.Future[(List[Int], List[String])]
我正在尝试实现一个API方法(AsyncWriteJournal.asyncWriteMessages- Akka 2.4的持久性API的一部分),它要求我返回一个Future[Seq[Try[Unit]]].这个想法是可以执行许多操作,其中任何操作可以单独成功或失败,未来可以用于等待所有操作的完成.即使在个别运营中出现某种类型的失败,未来本身也可以成功.
我正在使用的基础操作(Rediscala)返回Futures但我仍然试图将a Seq[Future[Unit]]转换为所需的返回类型.我可以Promise在每个操作上使用并将它们绑在一起,Future.sequence但如果任何操作失败,那么结果将来会失败,这不是正确的行为
假设我有以下一组代码在未来做了一些事情:
1 to 10 foreach {
case x => Future { x + x }
}
假设我给这段代码提供了默认的ExecutionContext,我知道后台会发生什么,但我想知道的是如何实现Future的处理呢？我的意思是应该有一些线程或一组线程可能等待Future完成？这些线程被阻止了吗？在他们真正等待未来完成的意义上被阻止了？
现在在以下场景中:
val x: Future[MyType] = finishInSomeFuture()
假设x有一个超时,我可以像这样调用:
Future {
blocking {
x.get(3, TimeOut.SECONDS)
}
}
我真的在阻止吗？是否有更好的异步超时方法？
编辑:以下Timeout比我上面定义的阻塞上下文有多么不同或有多好？
object TimeoutFuture {
def apply[A](timeout: FiniteDuration)(block: => A): Future[A] = {
val prom = promise[A]
// timeout logic
Akka.system.scheduler.scheduleOnce(timeout) {
prom tryFailure new java.util.concurrent.TimeoutException
}
// business logic
Future {
prom success block
}
prom.future
}
}
我需要处理几个对象,每个操作可能需要很长时间.
处理无法放在GUI(主)线程中,我在其中启动它.
我需要做的所有的一些对象在通信上的异步操作,类似的东西来std::async用std::future或QtConcurrent::run()在我的主要框架(Qt的5),用QFuture等,但它不提供线程的选择.我总是需要在一个额外的线程中使用选定的对象(objects == devices),
因为:
注意:串行端口始终以独占访问权限打开(即,没有其他进程或线程可以访问已打开的串行端口).
所以,我的问题.
如何实现该功能？
MyFuture<T> fut = myAsyncStart(func, &specificLiveThread);
一个活动线程必须多次传递.
我的设备没有互联网连接时，我试图捕获该错误。我建立了2种将来的方法，一种是导入json，另一种是查看数据库。我有一个将来的构建器，它假设在构建网格视图之前要等待两个将来的构建完成，但是由于连接错误，似乎offlineFlashCardList被过早地调用了。知道如何在调用快照错误之前使其等待两个期货完成吗？
import 'package:flutter/material.dart';
import 'package:flutter/foundation.dart';
import 'package:baby_sound/strings.dart';
import 'package:baby_sound/objects/flashCardList.dart';
import 'package:cached_network_image/cached_network_image.dart';
import 'dart:async' show Future;
import 'dart:convert';
import 'package:baby_sound/database/database.dart';
import 'package:baby_sound/objects/network.dart';
import 'package:http/http.dart' as http;
class GridViewWidget extends StatefulWidget{
@override
createState() => new GridViewState();
}
class GridViewState extends State<GridViewWidget>{
List<FlashCardList> flashCardList;
List<FlashCardList> offlineFlashCardList;
Future<List<FlashCardList>> fetchFlashCardList() async{
debugPrint("before response");
List<FlashCardList> tempFlashCardList;
final response = await http.get('some json url');
//checkConnection(url).then((response){
debugPrint ("after database load, response code: ${response.statusCode}");
if (response.statusCode == 200) {
var data = json.decode(response.body);
var flashCardListData = data["FlashCardList"] as List; …在Tokio文档中，有以下代码段：
extern crate tokio;
extern crate futures;
use futures::future::lazy;
tokio::run(lazy(|| {
for i in 0..4 {
tokio::spawn(lazy(move || {
println!("Hello from task {}", i);
Ok(())
}));
}
Ok(())
}));
对此的解释是：
该
lazy函数在第一次对将来进行轮询时运行关闭。在这里使用它来确保tokio::spawn从任务中调用。如果不使用lazy，tokio::spawn则会从任务的上下文外部调用它，从而导致错误。
尽管对Tokio有所了解，但我不确定我是否能准确理解。看来这两个lazy角色的作用略有不同，并且这种解释仅适用于第一个。难道不是在这里lazy（在for循环内）第二次调用将闭包转换为未来吗？