Concurrency complications in Golang function parameter passing

In the case of concurrent Goroutine modifying shared parameters, the following rules exist for Go function parameter passing: Pass by value: a copy is passed to the function, and changing the copy does not affect the original value. Pass by reference: A pointer is passed to a function, and changing the pointer value also modifies the original value. When passing by reference, multiple Goroutines modifying parameters simultaneously can cause concurrency complications. In shared data concurrency scenarios, pass-by-reference should be used with caution and in conjunction with appropriate concurrency control measures.

Concurrency Complications in Go Function Parameter Passing

In Go, function parameters can be passed by value or by reference. When passing by value, a copy of the parameter is passed to the function, whereas when passing by reference, modifications to the parameter are reflected in the calling function.

However, in a concurrent environment, this parameter passing pattern may lead to concurrency complications, because multiple concurrently executing Goroutines may modify the same parameter at the same time.

Pass by value

func modifyInt(i int) {
    i++ // 只修改 i 变量的副本
}

func main() {
    i := 0
    go modifyInt(i)
    fmt.Println(i) // 输出 0（原始值）
}

In the case of pass by value, although the modifyInt() function modifies the copy of the i passed to it , but the original i variables in the calling function are not affected.

Pass by reference

func modifyIntPointer(i *int) {
    *i++ // 修改 i 变量的实际值
}

func main() {
    i := 0
    go modifyIntPointer(&i)
    fmt.Println(i) // 输出 1（修改后的值）
}

In the case of pass by reference, modifications to the pointer parameter pointing to the original i variable will be reflected in the calling function. This can lead to concurrency complications, as multiple Goroutines may modify the same parameter at the same time.

Practical Case

Consider the following read-write lock case, which protects concurrent access to shared data.

type MutexMap struct {
    m map[string]int
    mu sync.Mutex // 互斥锁
}

func (m *MutexMap) Get(key string) int {
    m.mu.Lock() // 加锁
    defer m.mu.Unlock() // 解锁（延迟执行）
    return m.m[key]
}

func (m *MutexMap) Set(key string, value int) {
    m.mu.Lock()
    defer m.mu.Unlock()
    m.m[key] = value
}

If the m field of MutexMap is passed by reference, multiple Goroutines may lock at the same time, resulting in a deadlock.

Conclusion

In a concurrent environment, it is important to understand function parameter passing patterns and their potential impact on shared data. Passing by value is generally safer, while passing by reference should be used with caution and in conjunction with appropriate concurrency controls.

The above is the detailed content of Concurrency complications in Golang function parameter passing. For more information, please follow other related articles on the PHP Chinese website!