How Golang makes concurrent programming easier

In this article we will explore how Golang makes the use of concurrent threads more easy.

Goroutines

Goroutine is a function that runs concurrently with other goroutines inside the same program. They are ligth and eficient allowing that you execute countless goroutines.

Different of traditional threads Goroutines are managed by Go internally, make the use of them more easy for the developer, providing a better developer experience in use.

How use?

Now that we know what goroutines are, let’s see a real-world example of how to use them.

go createGoRoutine()        

To create a goroutine, we simply add the go keyword before the function call, and Go will handle the rest automatically.

We can also use anonymous functions with goroutines. Let’s look at an example:

This example is from an application where we listen to WebSocket messages from Binance and check if a cryptocurrency is close to a target buy price.

go func() {
    for {
        _, message, err := conn.ReadMessage()
        if err != nil {
            log.Printf("Error reading message: %v", err)
            return
        }
        var trade TradeMessage
        if err := json.Unmarshal(message, &trade); err != nil {
            log.Printf("Error processing message: %v", err)
            continue
        }
        log.Printf("New trade: %s - Price: %s", trade.Symbol, trade.Price)
    }
}()        

📌 What happens here?

• The goroutine allows the WebSocket listener to run in the background without blocking the main program.
• Each new message from Binance is processed concurrently, improving performance.

Goroutines make concurrent programming simpler and more efficient. In the next section, we can explore channels, which allow secure communication between goroutines.