当前位置：文江博客话题详情

什么是期货？

发布于 2024-07-04 20:15:18 字数 24 浏览 5 评论 0原文

什么是期货？这与惰性评估有关。

原文

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

汐鸠 2024-07-11 20:15:25

这篇博文一起给出了非常彻底的解释并举例说明如何自己实现未来。我真的推荐它:)

回复收藏 0 原文

柒夜笙歌凉 2024-07-11 20:15:24

Future 也用于某些设计模式，特别是实时模式，例如 ActiveObject 模式，它将方法调用与方法执行分开。未来被设置为等待完成执行。当您需要从多线程环境转移到与单线程环境通信时，我倾向于看到它。在某些情况下，硬件不具有线程的内核支持，并且在这种情况下使用 future。乍一看，你如何沟通并不明显，令人惊讶的是，Future 让它变得相当简单。我有一些 C# 代码。我会把它挖出来并发布。

回复收藏 0 原文

幼儿园老大 2024-07-11 20:15:23

Wiki 文章对 Future 进行了很好的概述。该概念通常用在并发系统中，用于对可能已计算或尚未计算的值进行调度计算，并且进一步，其计算可能正在进行或尚未进行。

来自文章：

未来与
计算其的特定线程
价值。该计算可以开始
要么在未来到来时热切地
创建，或在其值为时懒惰地创建
首先需要。

文章中没有提到，futures 是一个 Monad，因此可以将函数投影到将未来值放入 monad 中，以便在未来值可用时将它们应用于未来值，从而产生另一个未来，而该未来又代表该函数的结果。

回复收藏 0 原文

软糯酥胸 2024-07-11 20:15:22

Future 封装了延迟计算，通常用于将惰性求值硬塞到非惰性语言中。第一次评估 future 时，将运行评估它所需的代码，并用结果替换 future。

由于 future 被替换，后续的计算不会再次执行代码，而只是产生结果。

回复收藏 0 原文

蓝海 2024-07-11 20:15:22

大家提到期货都是为了偷懒计算。然而，另一个并不像宣传的那样的用途是一般情况下使用 Futures for IO。特别是它们对于加载文件和等待网络数据非常有用

回复收藏 0 原文

微暖i 2024-07-11 20:15:21

当您创建 future 时，将启动一个新的后台线程，开始计算实际值。如果您请求未来的值，它将阻塞，直到线程完成计算。当您需要并行生成一些值并且不想手动跟踪所有值时，这非常有用。

对于 Ruby，请参阅 lazy.rb，或 Scala、futures 和延迟计算。

它们可能可以用任何带有线程的语言来实现，尽管在像 C 这样的低级语言中显然比在高级函数式语言中更困难。

回复收藏 0 原文

仙女 2024-07-11 20:15:20

有一篇关于期货的维基百科文章。简而言之，这是一种使用未知值的方法。然后可以根据需要计算该值（惰性计算），并且可以选择与主计算同时计算。

C++ 示例如下。

假设您要计算两个数字的总和。您可以采用典型的 eager 实现：

int add(int i, int j) { return i + j; }
// first calculate both Nth_prime results then pass them to add
int sum = add(Nth_prime(4), Nth_prime(2));

也可以使用 C++11 的 std::async 的 futures 方式，它返回一个 std::future。在这种情况下，add 函数仅在尝试使用尚未计算的值时才会阻塞（也可以创建一种纯粹的惰性替代方案）。

int add(future<int> i, future<int> j) { return i.get() + j.get(); }
int sum = add(async(launch::async, [](){ return Nth_prime(4); }),
              async(launch::async, [](){ return Nth_prime(2); }));

There is a Wikipedia article about futures. In short, it's a way to use a value that is not yet known. The value can then be calculated on demand (lazy evaluation) and, optionally, concurrently with the main calculation.

C++ example follows.

Say you want to calculate the sum of two numbers. You can either have the typical eager implementation:

int add(int i, int j) { return i + j; }
// first calculate both Nth_prime results then pass them to add
int sum = add(Nth_prime(4), Nth_prime(2));

or you can use the futures way using C++11's std::async, which returns an std::future. In this case, the add function will only block if it tries to use a value that hasn't yet been computed (one can also create a purely lazy alternative).

int add(future<int> i, future<int> j) { return i.get() + j.get(); }
int sum = add(async(launch::async, [](){ return Nth_prime(4); }),
              async(launch::async, [](){ return Nth_prime(2); }));

回复收藏 0 原文

~没有更多了~