How to use goroutine to implement parallel requests in go language

Golang is a very popular programming language. It has many unique features, one of the important features is that it supports parallel processing. In today's world, network requests have become part of our daily lives. If we need to request multiple APIs, how can we complete this task in the shortest possible time? This is exactly what the topic of golang parallel requests is about.

The so-called parallel request simply means initiating multiple network requests at the same time to improve the efficiency of the request. In golang, we can use goroutine to implement parallel requests to quickly process a large number of requests.

First, let’s take a look at how to use goroutine to implement parallel requests.

package main

import (
    "fmt"
    "net/http"
)

func main() {
    urls := []string{
        "http://example.com/1",
        "http://example.com/2",
        "http://example.com/3",
    }

    for _, url := range urls {
        go func(url string) {
            res, err := http.Get(url)
            if err != nil {
                fmt.Println("Error:", err)
                return
            }

            fmt.Println("Response:", res.Status)
        }(url)
    }

    fmt.Scanln()
}

In this example, we define a URLs array, which contains the URLs we need to request. We iterate over this array and start a new goroutine on each URL using the go keyword. This goroutine sends an HTTP GET request and outputs the response to the terminal after the request is completed.

Such simultaneous requests will make our program faster, but there will also be some problems. First, if we start too many goroutines, we may exceed the maximum concurrency allowed by the operating system. Secondly, we need to wait for all requests to complete before we can get the results, which may cause the response time to be too long, which means we need some more efficient processing methods.

Next, let’s take a look at how to use goroutine and channel to achieve more efficient parallel requests.

package main

import (
    "fmt"
    "net/http"
)

func main() {
    urls := []string{
        "http://example.com/1",
        "http://example.com/2",
        "http://example.com/3",
    }

    ch := make(chan string)

    for _, url := range urls {
        go func(url string) {
            res, err := http.Get(url)
            if err != nil {
                fmt.Println("Error:", err)
                return
            }

            ch <- fmt.Sprintf("Response from %s: %s", url, res.Status)
        }(url)
    }

    for i := 0; i < len(urls); i++ {
        fmt.Println(<-ch)
    }
}

In this example, we define a channel named ch, and we send the results to the channel in each goroutine. In the main thread, we use a loop to receive all the results in the channel and print them to the terminal.

The advantage of using channels is that we can control the number of goroutines, and we do not need to wait for all goroutines to complete the request to get the result. Compared with waiting for all requests to complete, such parallel requests can allow us to get results faster, and also avoid lags caused by long response times for requests.

In summary, golang parallel request is a method that uses the characteristics of the golang language to process multiple network requests at the same time, thereby improving request efficiency. In implementing parallel requests, we can use goroutine and channel to control the concurrency of the program and return the results immediately after receiving the response of each request, allowing us to process a large number of requests in the shortest time.

The above is the detailed content of How to use goroutine to implement parallel requests in go language. For more information, please follow other related articles on the PHP Chinese website!