golang 동시 요청-Golang-php.cn

최신 웹 애플리케이션에서 네트워크 요청은 중요한 부분입니다. 네트워크 요청을 통해 우리는 쉽게 데이터를 얻고 보낼 수 있습니다. 그러나 애플리케이션의 크기가 계속 증가함에 따라 요청 수도 증가합니다. 이 경우 시스템의 안정성과 효율성을 어떻게 보장할 것인지가 특히 중요합니다.

Go 언어는 우수한 메모리 관리 및 동시성 제어 기능을 갖춘 효율적인 동시 프로그래밍 언어이므로 높은 동시 요청을 처리하는 데 탁월합니다. 이 기사에서는 Go 언어를 사용하여 동시 요청을 처리하는 방법을 소개합니다.

요청 동시 처리

일반적으로 네트워크 요청은 연결 설정, 요청 보내기, 응답 받기의 세 단계로 구성됩니다. 기존 애플리케이션에서는 각 요청이 다음 세 단계를 통해 진행됩니다. 그러나 동시성이 높은 애플리케이션에서는 각 요청이 실행을 시작하기 전에 이전 요청이 완료될 때까지 기다려야 하기 때문에 이 접근 방식은 비효율적입니다.

여기에는 다른 접근 방식이 있습니다. Go 언어의 동시성 기능을 사용하여 여러 요청을 동시에 실행할 수 있으므로 애플리케이션이 동시에 여러 요청을 처리할 수 있습니다.

다음은 간단한 예제 코드입니다.

func main() {
    urls := []string{
        "http://example.com",
        "http://example.net",
        "http://example.org",
    }

    ch := make(chan string)

    for _, url := range urls {
        go fetch(url, ch)
    }

    for range urls {
        fmt.Println(<-ch)
    }
}

func fetch(url string, ch chan<- string) {
    resp, err := http.Get(url)
    if err != nil {
        ch <- fmt.Sprint(err)
        return
    }
    defer resp.Body.Close()

    text, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        ch <- fmt.Sprint(err)
        return
    }

    ch <- fmt.Sprintf("url:%s, body:%s", url, text[:100])
}

로그인 후 복사

이 예제에서는 여러 URL이 포함된 조각을 정의합니다. 그런 다음 버퍼링된 채널을 만들고 go 키워드를 사용하여 각 요청을 동시에 처리하는 goroutine을 시작했습니다. 고루틴에서는 단일 요청을 처리하는 것과 동일한 단계를 수행하고 채널을 사용하여 결과를 기본 프로그램으로 다시 보냅니다. 마지막으로 간단한 for range 루프를 사용하여 모든 요청이 완료될 때까지 기다렸다가 결과를 인쇄합니다. go关键字来启动一个goroutine，同时处理每个请求。在goroutine中，我们执行与处理单个请求相同的步骤，并使用通道来将结果发送回主程序。最后，我们使用一个简单的for range循环来等待所有请求完成并打印结果。

控制并发量

在上面的示例中，我们使用了goroutine来并发处理多个请求。但是这样做可能导致系统被过多的请求阻塞而崩溃。为了避免这种情况，我们需要控制并发量。

在Go语言中，sync包中的WaitGroup结构可以很好地解决这个问题。这个结构允许我们在代码块中增加并发数量，并等待所有任务完成后再继续执行。下面是一个简单的示例代码：

func main() {
    urls := []string{
        "http://example.com",
        "http://example.net",
        "http://example.org",
    }

    var wg sync.WaitGroup

    for _, url := range urls {
        wg.Add(1)
        go func(url string) {
            defer wg.Done()

            resp, err := http.Get(url)
            if err != nil {
                fmt.Println(err)
                return
            }
            defer resp.Body.Close()

            body, err := ioutil.ReadAll(resp.Body)
            if err != nil {
                fmt.Println(err)
                return
            }

            fmt.Printf("url:%s, body:%s", url, body[:20])
        }(url)
    }

    wg.Wait()
}

로그인 후 복사

在这个示例中，我们首先定义一个WaitGroup变量。在循环中，我们使用Add方法增加并发数量计数。然后，我们启动一个goroutine来处理每个请求。最后，我们使用Wait方法来等待所有goroutine完成并恢复执行。

并发地处理请求结果

在处理多个请求时，我们不仅需要控制并发量，还需要处理并发结果。一般而言，我们需要把所有请求的结果收集到一个数组或其他数据结构中，并在所有请求完成后进行处理。

Go语言中，我们可以使用sync包中的Mutex结构组织多个goroutine对数据结构的访问。Mutex可以防止多个goroutine同时修改共享资源，并确保同一时间只有一个goroutine可以访问。

下面是一个示例代码：

type Result struct {
    url string
    body []byte
    err error
}

func fetch(url string, ch chan<- Result) {
    resp, err := http.Get(url)
    if err != nil {
        ch <- Result{url: url, err: err}
        return
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        ch <- Result{url: url, err: err}
        return
    }

    ch <- Result{url: url, body: body}
}
func main() {
    urls := []string{
        "http://example.com",
        "http://example.net",
        "http://example.org",
    }

    var results []Result
    ch := make(chan Result)

    for _, url := range urls {
        go fetch(url, ch)
    }

    for range urls {
        results = append(results, <-ch)
    }

    for _, result := range results {
        if result.err != nil {
            fmt.Println(result.err)
            continue
        }
        fmt.Printf("url:%s, body:%s", result.url, result.body[:20])
    }
}

로그인 후 복사

在这个示例中，我们定义了一个Result结构来保存每个请求的返回值。然后，我们创建了一个缓冲通道，并使用goroutine并发执行每个请求。在goroutine中，我们使用Mutex来确保共享资源不会被多个goroutine同时访问。最后，我们使用一个循环等待所有请求完成，并收集结果到一个数组中。最后，我们遍历结果数组并打印每个请求的返回值。

总结

使用Go语言处理并发请求可以大大提高系统的效率和可靠性。在应用程序需要处理大量请求时，我们应该使用goroutine和通道来并发执行请求，并使用WaitGroup和Mutex

sync

WaitGroup

Add

Wait

sync

Mutex

Result

Mutex

WaitGroup

Mutex