Golang function memory safety programming practice

Writing memory-safe code in Go is critical to prevent program crashes, data corruption, and security vulnerabilities. Practices include: passing pointers, using slice capacity, avoiding buffer overflows, using slices with caution, using make() to create slices and maps, using defer to release resources, and using sync.Mutex to synchronize concurrent access. Following these practices can improve the robustness and reliability of your code and be reflected in practical cases.

Go Functional Memory-Safe Programming Practices

Writing memory-safe code in Go is critical to prevent program crashes, data corruption, and security vulnerabilities. Following the following practices can help improve the robustness and reliability of your code.

Passing a pointer

Passing a pointer (*T) instead of a value (T) prevents accidental modification of the passed-in value. For example:

func Swap(a, b *int) {
  *a, *b = *b, *a
}

Using slice capacity

Slices ([]T) are based on the underlying array, so understanding its capacity is crucial. Capacity represents the maximum length of the array. When capacity is exceeded, Go will automatically allocate a larger underlying array, thus changing the address of the slice.

The following code demonstrates this:

s := []int{1, 2, 3}
println(len(s), cap(s))  // 3 3

s = append(s, 4)
println(len(s), cap(s))  // 4 6

Avoiding buffer overflows

A buffer overflow occurs when the amount of data stored exceeds the buffer allocated to it. In Go, you can avoid this situation using the following methods:

• Use fixed-length arrays: Arrays are allocated a fixed space at compile time and are guaranteed not to overflow.
• Use slices and manage their capacity properly: Keep track of the length and capacity of your slices and adjust them as needed.
• Use copy() Function: copy() Ensure that the amount of copied data does not exceed the capacity of the target buffer.

Use slices with caution

Slices are not memory-safe types because they share the underlying array. Modifications to a slice may unexpectedly affect other variables that use the same array.

The following example illustrates this:

s1 := []int{1, 2, 3}
s2 := s1[1:]

s1[0] = 4
println(s1)  // [4 2 3]
println(s2)  // [2 3]

Create slices and maps using make()

make()

Explicitly creating slices and maps lets you specify their initial capacity and avoid unnecessary allocations. Use

defer

to release resources. The

defer

statement ensures that a block of code is executed before the function returns. This is useful for freeing resources such as open files or network connections. The following example uses

defer

to close the file: <pre class='brush:go;toolbar:false;'>func main() { file, err := os.Open(&quot;file.txt&quot;) if err != nil { return } defer file.Close() // 执行其他操作 }</pre>Using

sync.Mutex

sync.Mutex

is a mutex lock used to synchronize concurrent access to shared resources. Mutex You can acquire and release locks through the Lock() and Unlock() methods. The following example uses

sync.Mutex

to protect concurrent access to shared data: <pre class='brush:go;toolbar:false;'>var mu sync.Mutex var count int func main() { for i := 0; i &lt; 10; i++ { go func() { mu.Lock() defer mu.Unlock() count++ }() } // 等待所有协程完成 }</pre>Practical case

Consider a calculation that calculates the intersection of two slices Function:

func Intersection(s1, s2 []int) []int {
  var res []int
  for _, v1 := range s1 {
    for _, v2 := range s2 {
      if v1 == v2 {
        res = append(res, v1)
      }
    }
  }
  return res
}

We can improve the memory safety of this function by following the following principles:

Use slice capacity to avoid unnecessary allocations.

• Use the
copy()
• function to append elements safely. Use
make()
• to create slices explicitly.
The final improved code is as follows:

func Intersection(s1, s2 []int) []int {
  res := make([]int, 0, min(len(s1), len(s2)))
  for _, v1 := range s1 {
    for _, v2 := range s2 {
      if v1 == v2 {
        copy(res[len(res):], []int{v1})
      }
    }
  }
  return res
}

Following these practices helps to write memory-safe Go functions and improve the robustness, reliability and security of the code.

The above is the detailed content of Golang function memory safety programming practice. For more information, please follow other related articles on the PHP Chinese website!