blocks|key|1200327|text|当然，只是省略了await。通过这种方式，将立即调用callee()，并在调用异步操作时，将调用调度到事件队列中，以便稍后执行，然后继续执行caller()。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1200328|不过，这可不像一条线。如前所述，处理将排队到事件队列，这意味着在当前任务和所有以前排队的任务完成之前不会执行它。|1200329|如果您想要真正的并行执行，您需要利用隔离。|1200330|另请参阅|1200331|https://www.dartlang.org/articles/event-loop/|unordered-list-item|1200332|https://api.dartlang.org/stable/1.16.1/dart-isolate/dart-isolate-library.html|1200333|https://pub.dartlang.org/packages/isolate|1200334|entityMap|0|LINK|mutability|MUTABLE|url|1|2^0|8|5|Q|8|1Y|8|0|0|0|0|0|19|0|0|0|25|1|0|0|15|2|0^^$0|@$1|2|3|4|5|6|7|11|8|@$9|12|A|13|B|C]|$9|14|A|15|B|C]|$9|16|A|17|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|18|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|19|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|1A|8|@]|D|@]|E|$]]|$1|L|3|M|5|N|7|1B|8|@]|D|@$9|1C|A|1D|1|1E]]|E|$]]|$1|O|3|P|5|N|7|1F|8|@]|D|@$9|1G|A|1H|1|1I]]|E|$]]|$1|Q|3|R|5|N|7|1J|8|@]|D|@$9|1K|A|1L|1|1M]]|E|$]]|$1|S|3|-4|5|6|7|1N|8|@]|D|@]|E|$]]]|T|$U|$5|V|W|X|E|$Y|M]]|Z|$5|V|W|X|E|$Y|P]]|10|$5|V|W|X|E|$Y|R]]]]

Sure, just omit <code>await</code>. This way <code>callee()</code> is called immediately and when an async operation is called the call will be scheduled in the event queue for later execution and <code>caller()</code> is continued immediately afterwards.

This isn't like a thread though. As mentioned processing is enqueued to the event queue which means it won't be executed until the current task and all previously enqueued tasks are completed.

If you want real parallel execution you need to utilize isolates.

See also 

<ul>
<li><a href="https://www.dartlang.org/articles/event-loop/" rel="noreferrer">https://www.dartlang.org/articles/event-loop/</a></li>
<li><a href="https://api.dartlang.org/stable/1.16.1/dart-isolate/dart-isolate-library.html" rel="noreferrer">https://api.dartlang.org/stable/1.16.1/dart-isolate/dart-isolate-library.html</a></li>
<li><a href="https://pub.dartlang.org/packages/isolate" rel="noreferrer">https://pub.dartlang.org/packages/isolate</a></li>
</ul>

blocks|key|1953439|text|调用callee函数时，它将返回一个Future。然后，await将等待这个未来的完成。如果您不等待未来，它最终还是会完成，但是您的caller函数在等待时不会被阻塞。所以，你可以这么做：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1953440|caller()+{
++callee();++//+Ignore+returned+Future+(at+your+own+peril).
}|code-block|syntax|javascript|1953441|如果您这样做，您应该知道如果callee失败时会发生什么错误。这将使返回的未来完成与该错误，如果您不听取未来，该错误被认为是“秘密”。未明错误由当前的Zone来处理，默认的行为就像一个顶级的未明错误，这可能会杀死您的隔离。|1953442|所以，请记住处理错误。|1953443|如果callee不能失败，太好了，您已经完成了(除非它无论如何都失败了，那么您会很高兴地调试它)。|1953444|实际上，由于忘记等待未来的风险，高度调整的皮棉要求您不只是忽略返回的未来，而是希望您执行unawaited(callee());来表示它是故意的。(+unawaited函数可以从package:meta导入，可以从SDK2.14版本的dart:async库中获得)。但是，unawaited函数不处理错误，所以如果您可能有错误，那么您应该做更多的事情。|1953445|您可以在本地处理错误：|1953446|caller()+{+
++callee().catchError((e,+s)+{+
++++logErrorSomehow(e,+s);+
++});+
}|1953447|(由于null安全性，此代码仅在callee()未来具有可空值类型时才能工作。从Dart+2.14开始，您将能够使用callee().ignore()，在此之前您可以使用callee().then((_)+=>+null,+onError:+(e,+s)+=>+logErrorSomehow(e,+s));。)|1953448|或者，您可以安装一个错误处理区域并在以下代码中运行代码：|1953449|runZoned(()+{
++myProgram();
},+onError:+logErrorSomehow);|1953450|请参见runZoned函数及其onError参数。|1953451|entityMap|0|LINK|mutability|MUTABLE|url|https://dart-lang.github.io/linter/lints/unawaited_futures.html|1|https://api.dartlang.org/stable/1.16.1/dart-async/runZoned.html^0|2|6|I|6|S|5|1U|6|0|0|E|6|23|4|0|0|2|6|0|18|K|23|9|2H|C|39|A|3S|9|L|2|0|0|0|0|G|8|1M|H|2D|1X|0|0|0|F|7|3|8|1|0^^$0|@$1|2|3|4|5|6|7|1E|8|@$9|1F|A|1G|B|C]|$9|1H|A|1I|B|C]|$9|1J|A|1K|B|C]|$9|1L|A|1M|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|1N|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1O|8|@$9|1P|A|1Q|B|C]|$9|1R|A|1S|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|1T|8|@]|D|@]|E|$]]|$1|O|3|P|5|6|7|1U|8|@$9|1V|A|1W|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1X|8|@$9|1Y|A|1Z|B|C]|$9|20|A|21|B|C]|$9|22|A|23|B|C]|$9|24|A|25|B|C]|$9|26|A|27|B|C]]|D|@$9|28|A|29|1|2A]]|E|$]]|$1|S|3|T|5|6|7|2B|8|@]|D|@]|E|$]]|$1|U|3|V|5|H|7|2C|8|@]|D|@]|E|$I|J]]|$1|W|3|X|5|6|7|2D|8|@$9|2E|A|2F|B|C]|$9|2G|A|2H|B|C]|$9|2I|A|2J|B|C]]|D|@]|E|$]]|$1|Y|3|Z|5|6|7|2K|8|@]|D|@]|E|$]]|$1|10|3|11|5|H|7|2L|8|@]|D|@]|E|$I|J]]|$1|12|3|13|5|6|7|2M|8|@$9|2N|A|2O|B|C]]|D|@$9|2P|A|2Q|1|2R]]|E|$]]|$1|14|3|-4|5|6|7|2S|8|@]|D|@]|E|$]]]|15|$16|$5|17|18|19|E|$1A|1B]]|1C|$5|17|18|19|E|$1A|1D]]]]

When you call the <code>callee</code> function, it returns a <code>Future</code>. The <code>await</code> then waits for that future to complete. If you don't await the future, it will eventually complete anyway, but your <code>caller</code> function won't be blocked on waiting for that. So, you can just do:
<pre class="lang-dart prettyprint-override"><code>caller() {
 callee(); // Ignore returned Future (at your own peril).
}
</code></pre>
If you do that, you should be aware of what happens if <code>callee</code> fails with an error. That would make the returned future complete with that error, and if you don't listen on the future, that error is considered &quot;uncaught&quot;. Uncaught errors are handled by the current <code>Zone</code> and the default behavior is to act like a top-level uncaught error which may kill your isolate.
So, remember to handle the error.
If <code>callee</code> can't fail, great, you're done (unless it fails anyway, then you'll have fun debugging that).
Actually, because of the risk of just forgetting to await a future, the highly reocmmended <a href="https://dart-lang.github.io/linter/lints/unawaited_futures.html" rel="noreferrer"><code>unawaited_futures</code> lint</a> requires that you don't just ignore a returned future, and instead wants you to do <code>unawaited(callee());</code> to signal that it's deliberate. (The <code>unawaited</code> function can be imported from <code>package:meta</code> and will be available from the <code>dart:async</code> library in SDK version 2.14).
The <code>unawaited</code> function doesn't handle errors though, so if you can have errors, you should do something more.
You can handle the error locally:
<pre class="lang-dart prettyprint-override"><code>caller() { 
 callee().catchError((e, s) { 
 logErrorSomehow(e, s); 
 }); 
}
</code></pre>
(Since null safety, this code only works if the <code>callee()</code> future has a nullable value type. From Dart 2.14, you'll be able to use <code>callee().ignore()</code> instead, until then you can do <code>callee().then((_) =&gt; null, onError: (e, s) =&gt; logErrorSomehow(e, s));</code> instead.)
or you can install an error handling zone and run your code in that:
<pre class="lang-dart prettyprint-override"><code>runZoned(() {
 myProgram();
}, onError: logErrorSomehow);
</code></pre>
See the <a href="https://api.dartlang.org/stable/1.16.1/dart-async/runZoned.html" rel="noreferrer">runZoned</a> function and it's <code>onError</code> parameter.

I have two functions

<pre><code>callee() async {
 // do something that takes some time
} 

caller () async {
 await callee();
}
</code></pre>

In this scenario, <code>caller()</code> waits till <code>callee()</code> finishes. I don't want that. I want <code>caller()</code> to complete right after invoking <code>callee()</code>. <code>callee()</code> can complete whenever in the future, I don't care. I just want to start it just like a thread and then forget about it.

Is this possible?

Invoking async function without await in Dart, like starting a thread

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我有两个功能callee() async {  // do something that takes some time} caller () async {  await callee();}在这个场景中，caller()一直等到callee()完成。我不想这样。我希望caller()在调用callee()之后立即完...

问调用异步函数，而无需在Dart中等待，就像启动线程一样
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问调用异步函数，而无需在Dart中等待，就像启动线程一样EN