How golang functions communicate with goroutine

Functions and Goroutine can communicate in the following ways: Mutex lock: used to protect shared resources Condition variable: used to notify Goroutine that meets the condition Channel: data transfer buffer Atomic variable: lock-free concurrent access variable Actual case: Parallel processing tasks, using Goroutine to improve the execution efficiency of computing-intensive tasks, specifically includes three steps: creating tasks, starting Goroutine processing tasks, and collecting processing results.

The communication method between functions and Goroutines in Go language

In Go language, functions and Goroutines can pass the following Communicate in three ways:

1. Mutex lock (Mutex)

Mutex lock is used to protect shared resources and ensure that only one Goroutine can access the resource at the same time .

var mu sync.Mutex // 全局互斥锁

func increment(i *int) {
    mu.Lock()
    *i++
    mu.Unlock()
}

2. Condition variable (Cond)

Condition variable is used to notify the waiting Goroutine when the specified condition is met.

var cond sync.Cond // 全局条件变量

func wait(c *sync.Cond, i *int) {
    c.L.Lock()
    for {
        if *i == 0 {
            c.Wait()
        }
        break
    }
    c.L.Unlock()
}

3. Channel

A channel is a buffer used to send data between Goroutines.

var ch = make(chan int, 10) // 创建容量为 10 的通道

func send(c chan int, i int) {
    c <- i // 发送数据
}

func receive(c chan int) {
    v := <-c // 接收数据
}

4. Atomic variables

Atomic variables can be accessed concurrently without locks.

var atomicInt int64

func incrementAtomic(i *int64) {
    atomicInt++
}

Practical Case: Parallel Processing Tasks

The following is a practical case of using Goroutine to process tasks in parallel:

// 任务类型
type Task struct {
    Num  int
    Chan chan int
}

func processTask(t *Task) {
    // 处理任务并返回结果
    result := t.Num * t.Num
    t.Chan <- result
}

func createTasks(n int) []*Task {
    // 创建 n 个任务
    tasks := make([]*Task, n)
    for i := 0; i < n; i++ {
        tasks[i] = &Task{
            Num:  i,
            Chan: make(chan int),
        }
    }
    return tasks
}

func main() {
    n := 10
    tasks := createTasks(n)

    // 启动 n 个 Goroutine 并行处理任务
    for _, t := range tasks {
        go processTask(t)
    }

    // 从任务中收集处理结果
    results := make([]int, n)
    for i := 0; i < n; i++ {
        results[i] = <-tasks[i].Chan
    }

    // 打印结果
    for _, r := range results {
        fmt.Println(r)
    }
}

Using Goroutine to process tasks in parallel can Significantly improve program execution efficiency, especially for computationally intensive tasks.

The above is the detailed content of How golang functions communicate with goroutine. For more information, please follow other related articles on the PHP Chinese website!