As pointed in the comments, you could do it in a new thread, using Queue. The drawback is that you’d still need some way to access the final result (what fmin returns at the end). My example below uses an optional callback to do something with it (another option would be to just yield it … Read more
You can use gather. From the Python documentation: import asyncio async def factorial(name, number): f = 1 for i in range(2, number + 1): print(f”Task {name}: Compute factorial({i})…”) await asyncio.sleep(1) f *= i print(f”Task {name}: factorial({number}) = {f}”) async def main(): # Schedule three calls *concurrently*: await asyncio.gather( factorial(“A”, 2), factorial(“B”, 3), factorial(“C”, 4), ) … Read more
TLDR: for and with are non-trivial syntactic sugar that encapsulate several steps of calling related methods. This makes it impossible to manually add awaits between these steps – but properly usable async for/with need that. At the same time, this means it is vital to have async support for them. Why we can’t await nice … Read more
runBlocking and other high-level coroutine utilities are not in the Kotlin standard library, but instead are a part of the library kotlinx.coroutines. To use this library in your project you must download its binaries and add a dependency on them to the project. Usually declaring a library dependency is a line or couple of lines … Read more
A graceful way is using error handling api. https://docs.python.org/3/library/asyncio-eventloop.html#error-handling-api Example: import asyncio async def run_division(a, b): await asyncio.sleep(2) return a / b def custom_exception_handler(loop, context): # first, handle with default handler loop.default_exception_handler(context) exception = context.get(‘exception’) if isinstance(exception, ZeroDivisionError): print(context) loop.stop() loop = asyncio.get_event_loop() # Set custom handler loop.set_exception_handler(custom_exception_handler) loop.create_task(run_division(1, 0)) loop.run_forever()
Fixing async As implemented, your someFun() will just “fire and forget” the async result. As a result, runBlocking does not make a difference in that test. If possible, make someFun() return async‘s Deferred and then, in runBlocking, call await on it. fun someFun(): Deferred<Unit> { // … Some synchronous code return async { suspendFun() } … Read more
As you’ve noticed, they all do the same thing. asyncio.async had to be replaced with asyncio.ensure_future because in Python >= 3.5, async has been made a keyword[1]. create_task‘s raison d’etre[2]: Third-party event loops can use their own subclass of Task for interoperability. In this case, the result type is a subclass of Task. And this … Read more
Coroutines aren’t threads. Coroutines are like threads that are never actively scheduled. So yes you are kinda correct that you would have to write you own scheduler to have both coroutines run simultaneously. However you are missing the bigger picture when it comes to coroutines. Check out wikipedia’s list of coroutine uses. Here is one … Read more
No, co-routines do not involve any kind of threads. Co-routines allow for cooperative multi-tasking in that each co-routine yields control voluntarily. Threads on the other hand switch between units at arbitrary points. Up to Python 3.4, it was possible to write co-routines using generators; by using yield or yield from expressions in a function body … Read more
Using just the kotlinx-coroutines-android version solves the problem. implementation ‘org.jetbrains.kotlinx:kotlinx-coroutines-android:0.30.1’