Golang Concurrent Programming Framework Guide: Goroutines: lightweight coroutines to achieve parallel operation; Channels: pipelines, used for communication between goroutines; WaitGroups: allows the main coroutine to wait for multiple goroutines to complete; Context: provides goroutine context information, Such as cancellations and deadlines.

Golang Concurrent Programming Framework Guide

Introduction

Concurrent programming in building high-performance and scalable applications crucial in the program. Golang provides a wealth of concurrency primitives, but choosing the right framework can further simplify and improve the efficiency of concurrent programming. This article will explore various popular Golang concurrent programming frameworks and show their practical cases.

1. Goroutines

Goroutines are lightweight coroutines in Golang that can run in parallel in different threads. They are very efficient and easy to use, especially suitable for CPU-intensive tasks.

package main

import (
    "fmt"
    "time"
)

func main() {
    // 創(chuàng)建一個(gè) goroutine 來(lái)打印消息
    go func() {
        for i := 0; i < 10; i++ {
            fmt.Println("Hello, world!")
            time.Sleep(100 * time.Millisecond)
        }
    }()

    // 主協(xié)程等待 goroutine 完成
    time.Sleep(10 * time.Second)
}

2. Channels

Channels are pipes used for communication between goroutines. They provide a safe and efficient way to pass values ??and synchronize operations.

package main

import (
    "fmt"
    "time"
)

func main() {
    // 創(chuàng)建一個(gè) channel 來(lái)傳遞值
    ch := make(chan string)

    // 創(chuàng)建一個(gè) goroutine 來(lái)發(fā)送數(shù)據(jù)到 channel
    go func() {
        ch <- "Hello, world!"
    }()

    // 接收 goroutine 發(fā)送的值
    msg := <-ch
    fmt.Println(msg)

    time.Sleep(10 * time.Second)
}

3. WaitGroups

WaitGroups allows the main coroutine to wait for multiple goroutines to complete. This helps ensure that execution of the main logic does not continue until all goroutines have finished running.

package main

import (
    "fmt"
    "sync"
)

func main() {
    // 創(chuàng)建一個(gè) WaitGroup
    wg := &sync.WaitGroup{}

    // 添加需要等待的 goroutine 數(shù)量
    wg.Add(2)

    // 創(chuàng)建并運(yùn)行 goroutines
    go func() {
        fmt.Println("Goroutine 1")
        wg.Done()
    }()

    go func() {
        fmt.Println("Goroutine 2")
        wg.Done()
    }()

    // 主協(xié)程等待 goroutines 完成
    wg.Wait()

    fmt.Println("All goroutines completed")
}

4. Context

Context provides contextual information in the goroutine, such as cancellation and deadline times. This helps manage concurrent requests and operations.

package main

import (
    "context"
    "fmt"
    "time"
)

func main() {
    // 創(chuàng)建一個(gè) context
    ctx, _ := context.WithTimeout(context.Background(), 5*time.Second)

    // 創(chuàng)建一個(gè) goroutine 并傳遞 context
    go func(ctx context.Context) {
        fmt.Println("Goroutine started")

        // 監(jiān)聽(tīng) context 是否已取消
        select {
        case <-ctx.Done():
            fmt.Println("Goroutine canceled")
            return
        }

        // ... 執(zhí)行其他操作
    }(ctx)

    // 等待 3 秒后取消 context
    time.Sleep(3 * time.Second)
    ctx.Done()
}

Conclusion

Golang provides powerful concurrent programming primitives, and these frameworks further simplify and improve the efficiency of concurrent programming. Choosing the right framework depends on the specific needs of your application. By understanding these frameworks, developers can build high-performance and scalable parallel programs.

The above is the detailed content of Which golang framework is most suitable for concurrent programming?. For more information, please follow other related articles on the PHP Chinese website!