Python asyncio event loop equivalent in Go lang

Question

I use asyncio event loop which is a kind of performing asynchronous/concurrency tasks in Python3.x .

Is there any equivalent of asyncio (async/await) or coroutines in Go lang on a thread only?

[NOTE]:

Not parallelism + concurrency (multiprocessing) pattern.

[UPDATE]:

Here is an asynchronous event loop using asyncio in Python for better sense:

import asyncio
import time

async def async_say(delay, msg):
    await asyncio.sleep(delay)
    print(msg)

async def main():
    task1 = asyncio.ensure_future(async_say(4, 'hello'))
    task2 = asyncio.ensure_future(async_say(6, 'world'))

    print(f"started at {time.strftime('%X')}")
    await task1
    await task2
    print(f"finished at {time.strftime('%X')}")

loop = asyncio.get_event_loop()
loop.run_until_complete(main())

Out:

started at 13:19:44
hello
world
finished at 13:19:50

Any help would be greatly appreciated.

Questions seeking third-party resources such as libraries, are off-topic. Rather than asking for an equivalent to a language primitive, a better approach is to ask a question about a specific problem you're actually facing in Go, and how to address it. — Jonathan Hall, Nov 11 '18 at 15:46
Just ask what you need specifically. Your question is not just clear. — Shudipta Sharma, Nov 11 '18 at 15:58
@ShudiptaSharma I updated my question for better sense, I looking for an equivalent method/pattern in Go lang — Benyamin Jafari, Nov 11 '18 at 19:35

user4815162342 · Accepted Answer · 2018-11-11T22:38:49.240

9

In Python terms, the event loop is built into Go. You would launch two goroutines with go async_say(...) and wait for them to complete, for example using a channel or a wait group.

A straightforward translation of your code to Go could look like this:

package main

import "fmt"
import "time"

func async_say(delay time.Duration, msg string, done chan bool) {
    time.Sleep(delay)
    fmt.Println(msg)
    done <- true
}

func main() {
    done1 := make(chan bool, 1)
    go async_say(4 * time.Second, "hello", done1)
    done2 := make(chan bool, 1)
    go async_say(6 * time.Second, "world", done2)
    <-done1
    <-done2
}

Note that, unlike Python (and JavaScript, etc.), Go functions do not come in different colors depending on whether they are asynchronous or not. They can all be run asynchronously, and the equivalent of asyncio is built into the standard library.

edited Nov 11 '18 at 22:38

answered Nov 11 '18 at 20:25

user4815162342

141,790
18
296
355

Thanks again. Can you write the equivalent of example in question in Go? and what is the difference between thread, process, and coroutines in Go and how to access them? – Benyamin Jafari Nov 11 '18 at 21:19
2

@BenyaminJafari I've added a roughly equivalent example. *what is the difference between thread, process, and coroutines in Go and how to access them?* Those questions are way out of scope for a StackOverflow answer; you might want to consult a book on Go. – user4815162342 Nov 11 '18 at 22:39

kostix · Answer 2 · 2018-11-11T16:58:58.013

3

You don't need this in Go as in Go this would be an anti-pattern.

Instead, in Go, you have management of "pollable" descriptors — such as sockets — tightly integrated with the runtime and the goroutine scheduler. This allows you to write normal sequential code which will internally be handled via a platform-specific "eventful" interface (such as epoll on Linux, kqueue on FreeBSD and IOCP on Windows). As soon as a goroutine tries to perform any I/O on a socket and the socket is not ready, the goroutine gets suspended until that data is ready after which it will be resumed right at the place it has been suspended.

Hence in Go, you merely create a separate goroutine to serve each request which should be performed or served concurrently with the others and write plain sequential code to handle it.

For backrgound, start here and here.

The tutorials explaining how the Go scheduler works are, for instance, this and this.

edited Nov 11 '18 at 16:58

answered Nov 11 '18 at 16:53

kostix

51,517
14
93
176

Thanks for useful links and goroutines keyword like the `coroutines`. – Benyamin Jafari Nov 11 '18 at 19:49
I failed to parse that passage regarding corouties and the goroutines. Judging from your other comment, you might be confusing these two terms but [they are profoundly different](https://stackoverflow.com/a/18061564/720999). As the other person who answered your question suggested, you seem to lack even the most basic knowledge of Go. The "problem" with Go is that its approach to concurrency is vastly different from most other mainstream languages (maybe except Erlang) so you simply cannot sufficiently reason about it w/o gaining some basic familiarity with the language. – kostix Nov 12 '18 at 08:16
Start with [the tour](https://tour.golang.org) and then proceed to [books](https://github.com/golang/go/wiki/Books). If you're seriously determined learning Go, I'd recommend to jump straight to [GOPL](http://www.gopl.io/), otherwise start with something free, like [this one](https://www.golang-book.com/books/intro). – kostix Nov 12 '18 at 08:18
Thanks again. I thought that coroutine and goroutine are similar, So I've been the mistake. – Benyamin Jafari Nov 12 '18 at 08:31
1

A fun thing is that Russ Cox has recently posted an essay on [how coroutines could be fitted in Go](https://research.swtch.com/coro), and why this could be useful. I have a feeling coroutines will eventually become a part of the Go's standard library ;-) – kostix Jul 20 '23 at 11:23

Python asyncio event loop equivalent in Go lang

2 Answers2