Scala Futures for-使用值列表进行理解
Scala Futures是Scala编程语言中的一个特性，用于处理异步编程和并发操作。它提供了一种简洁的方式来处理异步任务的结果，并允许开发人员以更直观的方式编写并发代码。
在Scala中，Future是一个表示异步计算结果的容器。它可以在后台执行计算，并在计算完成后提供结果。使用Future，开发人员可以将耗时的操作（如网络请求、数据库查询等）放在后台执行，而不会阻塞主线程。
使用值列表进行理解Scala Futures意味着将多个Future对象组合成一个Future列表，并对其进行操作。这样可以同时处理多个异步任务，并在它们都完成后获取结果。
以下是使用值列表进行理解Scala Futures的步骤：
- 创建一个包含多个异步任务的Future列表。可以使用Future对象的工厂方法（如Future.apply）或使用组合操作（如map、flatMap等）来创建Future列表。
- 使用组合操作（如map、flatMap、filter等）对Future列表进行转换和过滤。这些操作可以在Future完成后对其结果进行处理，或者将多个Future对象组合成一个新的Future对象。
- 使用组合操作（如sequence、traverse等）对Future列表进行聚合。这些操作可以将多个Future对象组合成一个Future对象，以便在它们都完成后获取结果。
- 使用回调函数（如onComplete、onSuccess、onFailure等）处理Future的结果。这些回调函数可以在Future完成后执行特定的操作，如打印结果、处理异常等。
Scala Futures的优势包括：
- 简洁性：Scala Futures提供了一种简洁的方式来处理异步编程和并发操作，使代码更易于理解和维护。
- 并发性：使用Scala Futures，开发人员可以同时处理多个异步任务，并在它们都完成后获取结果，从而提高应用程序的并发性能。
- 可组合性：Scala Futures支持各种组合操作，如map、flatMap、filter、sequence等，使开发人员能够以更直观的方式编写并发代码。
- 异常处理：Scala Futures提供了处理异步任务中的异常的机制，开发人员可以使用回调函数来处理异常情况，从而增加代码的健壮性。
Scala Futures的应用场景包括：
- 网络请求：使用Scala Futures可以方便地处理并发的网络请求，如同时请求多个API接口并在它们都返回结果后进行处理。
- 数据库查询：使用Scala Futures可以异步执行数据库查询操作，并在查询完成后获取结果，从而提高数据库访问的并发性能。
- 并行计算：使用Scala Futures可以将多个计算任务并行执行，并在它们都完成后聚合结果，从而提高应用程序的计算性能。
腾讯云相关产品和产品介绍链接地址：
- 云服务器（CVM）：https://cloud.tencent.com/product/cvm
- 云数据库MySQL版（CDB）：https://cloud.tencent.com/product/cdb
- 云函数（SCF）：https://cloud.tencent.com/product/scf
- 云存储（COS）：https://cloud.tencent.com/product/cos
- 人工智能（AI）：https://cloud.tencent.com/product/ai
- 物联网（IoT）：https://cloud.tencent.com/product/iot
- 区块链（BCS）：https://cloud.tencent.com/product/bcs
- 视频直播（LVB）：https://cloud.tencent.com/product/lvb
请注意，以上链接仅为示例，具体的产品选择应根据实际需求进行评估和选择。
相关·内容
2回答
这是一个文体问题，也是我试图扩大我对Scala的理解的一个组合。
我有一个包含Future的列表，我想计算期货的值，转换为期权的值，并使用a展开列表以进行理解：
import scala.util.Try
import scala.concurrent._
import ExecutionContext.Implicits.global
val l= List(Future.successful(1),Future.failed(new IllegalArgumentException))
implicit def try2Traversible[A](xo: Try[A]): Itera
浏览 4提问于2013-04-15得票数 1
2回答
我曾尝试使用Scala Futures编写并行Mergesort。然而，当我在Eclipse的解释器中对一个大小为100000的列表运行我的算法时，一切都变得非常缓慢，最终我得到一条错误消息，告诉我内存不足。当我从命令行在解释器中运行它时，它已经挂在大小为10000的列表中(但现在我没有收到任何错误消息)。
为什么会发生这种情况，有解决办法吗？
import scala.actors.Future
import scala.actors.Futures._
object MergeSort{
def sort[T <% Ordered[T]](toBeSorted :List[
浏览 2提问于2013-03-24得票数 0
我正在尝试使用Scala来查找产生最大返回值的函数的参数，并且我希望并行执行该操作。因此，对于此函数：
def f(i: Long): Double = {
// do something with i and return a double
}
我想要找到范围(0，x)上的输入参数i，当传递给函数f时，它给出了最大值。这是到目前为止我得到的结果：
import scala.concurrent.ops._
def parMap(f: Long => (Double, Long), xs: List[Int]): Array[(Double, Long)] = {
val
浏览 2提问于2010-12-13得票数 2
回答已采纳
我需要同时对列表中的一些元素执行Future方法。我目前的实现是按顺序工作的，这对于节省时间来说并不是最优的。我是通过映射列表、调用每个元素上的方法并以这种方式处理数据来做到这一点的。 我的经理与我分享了一个链接，展示了如何使用for-comprehension同时执行Futures，但我无法看到/理解如何使用我的List实现这一点。 他和我分享的链接是https://alvinalexander.com/scala/how-use-multiple-scala-futures-in-for-comprehension-loop/ 下面是我当前的代码： private def method1
浏览 32提问于2021-09-29得票数 0
回答已采纳
2回答
我在一台主机上启动了两个远程actors，它们只是回显发送给它们的任何内容。然后，我创建另一个参与者，它发送一定数量的消息(使用!！)发送给两个参与者，并保存保存这些参与者的回复的Future对象的列表。然后我循环遍历这个列表，获取每个Future的结果。问题是，大多数情况下，一些期货永远不会回来，即使参与者声称它已经发送了回复。这个问题是随机发生的，有时它会遍历整个列表，但大多数时候它会在某个点被卡住，并无限期地挂起。
下面是在我的机器上产生问题的一些代码：
Sink.scala：
import scala.actors.Actor
import scala.actors.Actor._
i
浏览 1提问于2010-07-29得票数 5
1回答
跟踪已完成的期货
、、、
我在Scala中产生了大量(约100.000)个http-request任务作为Futures。这需要一段时间，所以我希望能够通过递增全局计数器来跟踪这些期货中有多少成功完成或失败。然而，我想要避免竞争条件。Scala中有没有创建原子计数器的选项？或者还有更好的办法吗？
代码如下所示：
val futures = for(i <- 0 until nSteps) yield future {
...
val content = blocking { ... http request ... }
process(content)
}
Await.result(Fut
浏览 13提问于2014-11-24得票数 1
我正在寻找一种方法，将任意长度的未来列表转换为未来列表。我使用的是Playframework，所以归根结底，我真正想要的是一个Future[Result]，但为了让事情更简单，让我们说Future[List[Int]]通常的方法是使用Future.sequence(...)，但有一个问题……我得到的列表中通常有大约10-20个期货，其中一个期货失败的情况并不少见(他们正在发出外部web服务请求)。而不是在其中一个失败的情况下重试所有的，我希望能够获得成功的并返回这些成功的。
例如，执行以下操作不起作用
import scala.concurrent._
import scala.concurr
浏览 85提问于2014-01-02得票数 121
回答已采纳
3回答
番石榴版同时使用火花壳
、、、
我试图使用星火-卡桑德拉-连接器通过火花壳上的数据，但我无法连接到我的集群。似乎存在版本错配，因为类路径包含来自其他地方的一个更老的番石榴版本，即使我在启动时指定了正确的版本。我怀疑这很可能是由默认情况下放入类路径中的所有Hadoop依赖关系造成的。
是否有火花壳只使用适当版本的番石榴，而没有摆脱所有Hadoop相关的数据，包括jars？
相关数据：
启动火花壳，显示它具有适当版本的番石榴：$ spark-shell --packages com.datastax.spark:spark-cassandra-connector_2.10:1.5.0-M3
:: loading settings
浏览 12提问于2015-12-10得票数 10
回答已采纳
1回答
在Scala2.10中，什么是正确的方法来编写一个返回将来的函数，当列表中的所有期货都完成时它就完成了？
经过研究和实验，我在Scala工作表中开发了下面的代码：
import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.duration._
import scala.concurrent._
object ws2 {
def executeFutures(futures: Seq[Future[Unit]]): Fut
浏览 3提问于2014-04-30得票数 12
回答已采纳
在处理Scala期货列表中的异常时，我遇到了问题。我在ruuner方法中调用ruuner方法，它处理输入文件并保存在Hive表中。代码如下
import scala.util.{Failure, Success}
import scala.concurrent._
import scala.concurrent.duration._
val spark = SparkSession.builder.master("yarn").enableHiveSupport().getOrCreate()
var argsList: List[Array[Stri
浏览 2提问于2020-06-30得票数 0
回答已采纳
3回答
我正在考古瑟尔的反应性编程课程，当我做其中一项作业时，我遇到了一些奇怪的事情。无论如何，通过这个扩展，我向未来伙伴对象添加了一些方法
implicit class FutureCompanionOps[T](val f: Future.type) extends AnyVal {
/** Returns a future that is always completed with `value`.
*/
def always[T](value: T): Future[T] = Future(value)
/** Returns a future that
浏览 5提问于2013-12-29得票数 12
回答已采纳
1回答
我从一个前同事那里继承了一些代码，在那里他开始使用futures (在Scala中)来处理Databricks中的一些数据。 我将它分成几个块，在类似的时间段内完成。但是没有输出，而且我知道他们没有使用onSuccess或Await或其他任何东西。 问题是，代码结束运行(不返回输出)，但Databricks中的块一直在执行，直到thread.sleep()部分。 我是Scala和futures的新手，不确定如何在所有futures结束运行后退出笔记本(我应该在future块之后使用dbutils.notebook.exit()吗？) 代码如下： import scala.concurrent
浏览 12提问于2021-07-13得票数 0
回答已采纳
每当我在Cassandra表中插入超过1000的数据并按id获取数据时，它就会抛出以下异常：
com.datastax.driver.core.exceptions.NoHostAvailableException: All host(s) tried for query failed (tried: localhost/127.0.0.1:9042 (com.datastax.driver.core.exceptions.BusyPoolException: [localhost/127.0.0.1] Pool is busy (no available connection and the
浏览 1提问于2017-12-20得票数 6
回答已采纳
我是Scala初学者，开始学习“Scala编程”。我偶然发现了下面的代码。
for (arg <- args)
println(arg)
书中说，arg的类型是val，而不是var。为什么会这样。
根据我对每一次迭代的理解，arg的值是改变的，因为它在每次循环时都持有新的值。
以下是我的问题
为什么arg val而不是var？
按照Scala，如果是val，则不能更改值(因为在Scala中它是最终值)。
此外，它是否会为每次迭代创建多个对象，以及在循环之后如何销毁对象？
我还知道scala中var和val之间的区别。我已经穿过了这个链接。
浏览 1提问于2017-05-25得票数 2
3回答
Scala Futures和Akka Futures有什么不同，其中一个比另一个更好吗？从概念上讲，它们看起来很相似，使得非阻塞、异步编程变得很容易。
浏览 1提问于2013-09-10得票数 2
3回答
请考虑以下几点：
import scala.concurrent._
import scala.concurrent.duration.Duration.Inf
import scala.concurrent.ExecutionContext.Implicits.global
def slowInt(i: Int) = { Thread.sleep(200); i }
def slowAdd(x: Int, y: Int) = { Thread.sleep(100); x + y }
def futures = (1 to 20).map(i => future(slowInt(i))
浏览 7提问于2014-03-30得票数 14
回答已采纳
1回答
我刚接触过Java的Scala，所以函数式编程对我来说还是有点难理解。我有一个游戏框架中的项目。我需要查询数据库以获得带有ids的行，并将它们显示在html模板中。
这是我的密码
def search(query: String) = Action.async{ request =>
val result = SearchEngine.searchResult(query)
val docs = result.map(DocumentService.getDocumentByID(_).map(doc => doc))
val futures = Futu
浏览 2提问于2016-11-15得票数 3
回答已采纳
好的，所以我对Scala非常陌生(昨天开始)。我一直在阅读有关并发性的文档，但未能找到如何在叉连接池中使用可调用函数运行更大的任务。这是我在Scala中将在Java中使用的草图。
private Object fjp{
val fjp:ForkJoinPool=new ForkJoinPool(Runtime.getRuntime.availableProcessors()*2)
var w:Int=0
def invokeObjects(collection:Collection[Callable[Map[String:Int]]]){
浏览 2提问于2015-03-12得票数 0
回答已采纳
2回答
我是scala的新手，我尝试在Scala2.10RC3中结合几个Futures。Futures应该按顺序执行。在文档中，定义了方法andThen，以便按顺序执行期货。我使用这种方法组合了几个Futures (参见下面的示例)。我的期望是它打印6，但实际上结果是0。我在这里做错了什么？我有两个问题：
首先，为什么结果是0。其次，如何组合多个Futures，使第二个Future的执行不会在第一个Future完成之前开始。
val intList = List(1, 2, 3)
val sumOfIntFuture = intList.foldLeft(Future { 0 }) {
case
浏览 1提问于2012-12-12得票数 10
回答已采纳
这是我的代码，有时会超时，因为谷歌有时需要超过1000毫秒才能返回。我可能遗漏了一些很简单的东西，但却找不到任何关于如何做到这一点的合适的文档。任何帮助都非常感谢！
final List<F.Promise<List<Event>>> promises = new ArrayList<F.Promise<List<Event>>>();
F.Promise<List<Event>> primaryCalendar = F.Promise.promise(() -> getEve
浏览 1提问于2014-09-23得票数 1
回答已采纳
1回答
在scala中，您将如何编写一个函数，该函数接受一系列的期货，运行它们，不断地重试失败的任何一个，并返回结果？
例如，签名可能是：
def waitRetryAll[T](futures: Seq[Future[T]]): Future[Seq[T]]
可配置超时的加成点，此时函数会失败，被调用者可以处理这种情况。
如果错误案例处理程序可以接收失败的期货列表，则奖励积分。
谢谢!
浏览 1提问于2020-01-07得票数 4
回答已采纳
我对Scala很陌生，请容忍我。我有一堆期货包裹在一个大数组里。期货公司已经做了艰苦的工作，仔细查看了几个TBs的数据，在我的应用程序的末尾，我想总结所有的结果，这样我就可以很好地展示它们。
我所拥有的期货收藏品如下：
Array[Future[List(String, String, String)]]
到目前为止，我所读到的关于理解力的所有资料都表明
val test: Seq[Seq[List[String]]] = Seq(Seq(List("Hello", "World"), List("What's", "Up"
浏览 3提问于2015-07-12得票数 4
下面的代码通过使用print语句模拟网上购物。我正在使用Future来模拟一个场景，在这个场景中，我同时向一个购物篮中添加了多个项目(我在购物篮中添加了每一个偶数项)。我想在最后，代码打印多少项已经添加到篮子。
我创建了5个未来对象(所以我希望结果是5)
我把每一个未来都存储在一个列表中。
我使用for循环等待每个未来的完成
我希望，在所有的期货已经执行，我选择他们的成功目标，并整理他们的价值观(加起来)。这是我无法编码的部分。
导入scala.concurrent.ExecutionContext.Implicits.global导入scala.util.{Failure，S
浏览 2提问于2016-12-28得票数 0
问题
这是scala.concurrent.Future的摘录
def firstCompletedOf[T](futures: TraversableOnce[Future[T]])(implicit executor: ExecutionContext): Future[T] = {
val p = Promise[T]()
val completeFirst: Try[T] => Unit = p tryComplete _
futures foreach { _ onComplete completeFirst }
p.future
}
我
浏览 2提问于2016-12-13得票数 4
回答已采纳
我试图使用版本2.14.1执行大量查询，例如：
case class Foo(id: String, x: Long, y: Long)
val list: List[Foo] = _
list.size = 100000
def find(id: String, x: Long, y:Long )
select
.where(_.id eqs id)
.and(_.ts >= x)
.and(_.ts < y)
.fetch()
}
list.map(f => find(f.id, f.x, f.y)
我得到了一
浏览 2提问于2017-08-21得票数 0
回答已采纳
3回答
假设我从一些URL下载了一个(可能很大的)图片列表。我正在使用Scala，所以我要做的是：
import scala.actors.Futures._
// Retrieve URLs from somewhere
val urls: List[String] = ...
// Download image (blocking operation)
val fimages: List[Future[...]] = urls.map (url => future { download url })
// Do something (display) when complete
fim
浏览 4提问于2012-10-27得票数 68
回答已采纳
我试图理解Future，所以我编写了一个Summer类，它划分一个列表，在n个不同的未来中执行它，并结合结果。它比不分割版本慢5倍以上，我想知道原因。这是我的基准：
import java.util.Date
object SummerMain {
def main(args: Array[String]) = {
val xs = List.fill(10000000)(1)
println("Starting")
val t = Timer()
val x = xs.foldLeft(0)(_+_
浏览 3提问于2015-01-07得票数 0
回答已采纳
2回答
我想给Futures.awaitAll打个电话.Futures. awaitAll被定义为awaitAll(timeout : Long, fts : Future[Any]*)。我尝试过传递一个List和一个Array，但两者都无法工作：
list = future1 :: future2 :: Nil
Futures.awaitAll(1000, list)
found : List[scala.actors.Future[Any]] required: scala.actors.Future[Any]
编辑：现在要做的是用可变数量的参数(1到n)以编程方式调用Futures.awai
浏览 2提问于2009-08-11得票数 1
回答已采纳
1回答
我是spark Scala程序员。我有一个火花工作，有子任务，以完成整个工作。我想使用to Futures来并行完成子任务。一旦完成整个工作，我必须返回整个工作的回应。 关于scala Futures，我听说一旦主线程执行并停止，剩下的线程就会被杀死，你也会得到空的响应。 我必须使用Await.result来收集结果。但是所有的博客都告诉你应该避免使用Await.result，这是一种糟糕的做法。 在mycase中使用Await.result是正确的还是错误的？ def computeParallel(): Future[String] = {
val f1 = Future { &#
浏览 16提问于2019-09-20得票数 0
我喜欢scala的类型安全，但我经常遇到的一个运行时错误是
Future.filter predicate is not satisfied
我可以理解为什么我会得到这个错误，只是在寻找如何最好地解决这个错误并优雅地处理它的建议，或者可能我做错了？
val r: Future[play.api.mvc.Result] = for {
account <- accountServer.get(...)
if account.isConfirmed
orders <- orderService.get(account, ...)
} yield {
...
}
如果帐
浏览 3提问于2016-01-03得票数 9
我已经写好了这段代码
import scala.concurrent.{Future}
import scala.concurrent.ExecutionContext.Implicits.global
import scala.util.{Failure, Success, Random}
object TestFuture2 {
def bigCalc() : Future[Int] = Future {
Thread.sleep(1000)
40
}
}
object Main2 extends App {
val x = TestFuture2.bigC
浏览 2提问于2015-06-11得票数 5
回答已采纳
2回答
这些与未来相关的类和Scala中的特性之间有什么联系，为什么它们被分散在不同的包上？
我发现了这些：
abstract class scala.actors.Future
object scala.actors.Futures
trait/object scala.collection.parallel.FutureThreadPoolTasks
trait scala.concurrent.FutureTaskRunner
trait scala.parallel.Future (the package consists of o
浏览 3提问于2011-06-03得票数 16
回答已采纳
2回答
我想在Scala中使用RateLimiter来限制方法调用的频率。
我需要类似于Guava实现的东西：
我知道我可以在本地使用Guava，但我想知道在Scala中是否有更好的本地解决方案，不管有没有Akka
浏览 2提问于2012-09-27得票数 3
回答已采纳
因此，我对数据库、slick和scala非常(非常)陌生，所以我使用了文档中的示例代码
我的问题是，由于某种原因，在查询返回数据之前，我必须多次运行它。在返回结果之前，我必须重新运行它至少3-4次。我使用for-循环重新运行查询，而且每次它们也不一定给出完全相同的结果。
要创建两个表，如下所示：
class Patients(tag: Tag) extends Table[(String, String, Int, String)](tag, "Patientss") {
def PID = column[String]("Patient Id",
浏览 2提问于2015-06-25得票数 0
回答已采纳
我正在尝试使用scala和spark从一个List和另一个RDD生成RDD。其思想是获取一个值列表，并生成一个索引，其中包含包含每个值的原始数据集的所有条目。下面是我正在尝试的代码
def mcveInvertIndex(foos: List[String], bars: RDD[Int]): RDD[(String, Iterable[Int])] = {
// filter function
def hasVal(foo: String)(bar: Int): Boolean =
foo.toInt == bar
// call to sc.para
浏览 89提问于2017-03-12得票数 1
回答已采纳
1回答
Java和Scala都是面向对象编程语言(Scala也具有功能)。我是Scala的新手，据我的理解，Scala比Java (就OOP而言)是一种改进。Java中有哪些特性/功能，但还没有在Scala中引入呢？以下是我所知道的少数几个问题：
Scala没有静态。取而代之的是它有对象。
Scala没有“检查异常”的概念。
Scala中没有原语。
浏览 1提问于2013-10-16得票数 3
回答已采纳
在StackOverflow上有一些关于如何处理期货列表的建议，但我想尝试我自己的方法。但是我不能编译下面的代码
我有一份未来的清单。我想数一下他们中有多少人通过或失败了。我应该获取(2,1)，我将它存储在一个元组中，我想要采取的方法是遍历列表的每个元素。列表的元素是FutureInt。对于每个元素，我调用flatMap，它调用下一个递归周期(我假设如果flatMap被调用，那么这个特定的未来就会成功，所以我递增传递计数)。类似地，我想在恢复和增量失败计数中调用下一个递归周期，但我在其中得到了编译错误。
import scala.concurrent._
import scala.concur
浏览 2提问于2016-12-31得票数 0
1回答
可变数量的期货
、、、、
我必须在Scala中的2D列表上执行一些操作，我正在尝试并行化这项任务。
目前我有三个Futures，每个都取矩阵的N行并执行必要的计算。它是这样写的：
val future1: Future[List[Int]] = Future { makeCalculations(0, 5) }
val future2: Future[List[Int]] = Future { makeCalculations(6, 10) }
val future3: Future[List[Int]] = Future { makeCalculations(11, 15) }
然后，我同时启动它们，使用产生返回值列
浏览 2提问于2017-06-12得票数 1
1回答
我正在尝试使用Scala开发一个Akka应用程序，并且我想使用Light弯曲遥测记录应用程序的行为:肉桂、Grafana + Prometheus。
我按照本教程设置了sbt的所有内容
每个操作都很好，但只有当我从命令行运行应用程序时，肉桂才会启动。
sbt clean compile
sbt run
我可以看到控制台里的日志
[info] [INFO] [02/14/2022 10:58:15.480] [main-1] [Cinnamon] Agent version 2.16.2
[info] [INFO] [02/14/2022 10:58:16.362] [main-1] [Cinn
浏览 8提问于2022-02-14得票数 0
回答已采纳
我最近开始从事Scala的工作，偶然发现了它的名为Future的特性。我发布了一个问题，寻求关于我的代码的帮助和一些来自它的帮助。
在那次对话中，我被告知不建议从Future中检索该值。
我知道它在执行时是一个并行进程，但如果不建议检索Future的值，我如何/何时访问它的结果？如果Future的目的是运行独立于主线程的线程/进程，为什么不建议访问它？Future会自动将其输出分配给调用者吗？如果是这样，我们如何知道何时访问它？
我写了下面的代码来返回一个带有Map[String, String]的未来。
def getBounds(incLogIdMap:scala.collection.m
浏览 1提问于2019-04-10得票数 0
例如，Folly支持可在中找到的非阻塞组合器collectN
它没有提供一个非阻塞的组合器collectNWithoutException，它只会收集类似于collectAny的成功的未来，但不只是一个结果的未来。
Scala似乎只提供了firstCompletedOf，这将是带有n个== 1的collectN。
如果Scala不支持这些非阻塞组合子，我该如何轻松地实现它们呢？我想使用现有的组合子来实现。
浏览 1提问于2018-09-19得票数 4
我没有配置任何超时值，而是使用默认设置。在哪里配置3600秒超时？如何解决？
错误消息：
18/01/10 13:51:44 WARN Executor: Issue communicating with driver in heartbeater
org.apache.spark.rpc.RpcTimeoutException: Futures timed out after [3600 seconds]. This timeout is controlled by spark.executor.heartbeatInterval
at org.apache.spark.rpc.Rp
浏览 0提问于2018-01-12得票数 5
3回答
我是Scala的新手，所以请温文点。
在我目前正在构建的应用程序中，我正在使用Akka角色，并且我想编写一些单元测试。我偶然发现了这个
但我不能确切地理解它是如何工作的。特别地，
val actorRef = TestActorRef(new MyActor)
// hypothetical message stimulating a '42' answer
val future = actorRef ? Say42
val Success(result: Int) = future.value.get
result must be(42)
当我尝试这样做的时候，我得到了not
浏览 4提问于2013-05-28得票数 9
回答已采纳
我正在学习scala期货，我已经回答了我的问题。我有一个很简单的例子
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent._
import scala.util.{Failure, Success}
/**
* Created by dummy on 05/02/15.
*/
object FutureUtils extends App{
val f = Future {
Thread.sleep(1000)
println("I am learni
浏览 3提问于2015-02-05得票数 2
回答已采纳
在Python中，我使用一个名为futures的库，它允许我以简洁和清晰的方式使用N个工作进程池进行处理工作：
schedulerQ = []
for ... in ...:
workParam = ... # arguments for call to processingFunction(workParam)
schedulerQ.append(workParam)
with futures.ProcessPoolExecutor(max_workers=5) as executor: # 5 CPUs
for retValue in executor.map(
浏览 1提问于2014-12-12得票数 0
回答已采纳
我试图将 of ( Redis客户端之一)转换为scala，但在编译错误时说参数表达式的类型不兼容。
这是我的密码
def RunAsync() = {
val redisClient = new RedisClient(RedisURI.create(connURL))
val connection = redisClient.connectAsync()
connection.setAutoFlushCommands(false)
val futures = Lists.newArrayList[RedisFuture[_]]()
for
浏览 0提问于2015-12-29得票数 2
回答已采纳
我有不同的n来源，比如说，获得美元对欧元的利率。让n = 3和消息来源是Google，Yahoo，MyRates，并使用相应的方法：
def getYahooRate:Double = ???
def getGoogleRate:Double = ???
def getMyRate:Double = ???
我想以这样的方式询问美元对欧元的汇率，这样所有的n源都会被并行地进行调查，并且收到的第一个答复将立即被返回。如果在指定的时间范围内没有回复，则会引发异常。
使用Scala (如果需要的话，Akka)实现这一点的规范方法是什么？
是否有任何库方法可以完成这些工作？
编辑:这是我尝试过的。请就
浏览 1提问于2016-04-18得票数 0
回答已采纳
我在试着对付futures。这两者有很大的区别吗？
//1
import scala.concurrent.Await
import scala.concurrent.Future
import scala.concurrent.duration._
def longRequestToServer(): String = {...}
val future = Future { longRequestToServer() }
val resultAsync = Await.result(future, 60.seconds)
和
//2
val resultSync = try {
lo
浏览 1提问于2013-11-24得票数 1
回答已采纳
1回答
对文件的同步写入
、、
我知道在写入文件时要进行同步很容易，但问题是当有多个文件时，我们需要对每个文件进行同步。我已经写了一些这样的代码，让人们更容易理解我所说的话
import java.io._
import java.util.concurrent.{ConcurrentHashMap, ConcurrentMap}
import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global
object Main {
val lock: ConcurrentMap[String, Boolean]
浏览 0提问于2018-07-05得票数 0
1回答
我正在使用Scala的理解，等待几个期货将被执行。但我还希望处理onFailure (我希望将错误消息写入日志)。我怎样才能实现它呢？
这是我的代码：
val f1 = Future {...}
val f2 = Future {...}
for {
res1 <- f1
res2 <- f2
} {
// this means both futures executed successfully
process(res1, res2)
}
浏览 1提问于2015-06-10得票数 4
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
对象存储
即时通信 IM活动推荐
腾讯云开发者
