Efficiency analysis of function parameter passing in Golang

Golang function parameter passing has two methods: value passing and reference passing. Passing by value creates a copy of the parameter, which is safe but expensive; passing by reference passes the parameter pointer, which is cheap but carries the risk of modifying the original value and concurrency issues.

Efficiency analysis of function parameter passing in Golang

Function parameter passing plays an important role in program performance, especially for Large data structures or complex objects. Golang provides two methods of passing function parameters: value passing and reference passing.

Value passing

Value passing creates a copy of the parameter value and passes it to the function. This is a safe method of passing because modifications to the parameters inside the function do not affect the caller's original values. However, if the parameters passed are large data structures or complex objects, additional memory overhead and copy time will be incurred.

func foo(x int) {
    x++ // 修改 x 的副本，不会影响调用者原始值
}

Pass by reference

Pass by reference passes the pointer of the parameter, not the value itself. This can significantly reduce memory overhead and copy time, especially when passing large data structures or complex objects. However, passing by reference has the following disadvantages:

1. Modify parameters: Modifying the parameter pointer inside the function will affect the caller's original value.
2. Concurrency issues: If the parameter is a shared resource, passing by reference may cause concurrency issues.

func foo(x *int) {
    *x++ // 修改原始值，因为传递的是指针
}

Practical case

The following is a practical case comparing the performance of value passing and reference passing:

package main

import (
    "fmt"
    "time"
)

type LargeStruct struct {
    Data []byte
}

func main() {

    // 创建一个大型结构
    largeStruct := &LargeStruct{Data: make([]byte, 1000000)}

    // 使用值传递
    start := time.Now()
    for i := 0; i < 100000; i++ {
        foo(largeStruct)
    }
    elapsed1 := time.Since(start)

    // 使用引用传递
    start = time.Now()
    for i := 0; i < 100000; i++ {
        fooPtr(largeStruct)
    }
    elapsed2 := time.Since(start)

    fmt.Println("值传递耗时：", elapsed1)
    fmt.Println("引用传递耗时：", elapsed2)
}

func foo(largeStruct LargeStruct) {}

func fooPtr(largeStruct *LargeStruct) {}

In this case, Passing by value is much slower than passing by reference because the entire large structure is copied every time the foo function is called.

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