The Go language is loved by developers for its concise syntax and powerful concurrency performance. However, to take full advantage of Go’s potential, we need to understand how to optimize Go programs. This article will introduce some common Go language optimization techniques and illustrate them with practical examples.
1. Utilization Reduce memory allocation
In Go, frequent memory allocation and release can cause performance issues. It can be used to store and reuse temporary objects, thereby reducing the overhead of memory allocation and garbage collection.
var bufPool = {
New: func() interface{} {
return make([]byte, 1024)
},
}
buf := ().([]byte)
// Use buf...(buf)
In this example, we create a storing byte slices. When we need a byte slice, we first try to get it from the pool, and if there is no object available in the pool, the New function will be called to create a new byte slice. After using the byte slice, we put it back into the pool for subsequent multiplexing.
2. Use buffered channels for asynchronous operation
Go's channel is a mechanism for communicating between goroutines. The buffer channel can be used for asynchronous operations, thereby improving the concurrency performance of the program.
ch := make(chan int, 100) // Create a channel with a buffer size of 100
go func() {
for i := 0; i < 100; i++ {
ch <- i // Send data to the channel }
close(ch)
}()
for i := range ch { // Receive data from the channel (i)
}
In this example, we create a channel with a buffer size of 100. Then we start a goroutine to send data to the channel, and the master goroutine receives data from the channel. Since the channel is buffered, the sender and the receiver can work in parallel, thereby improving the concurrency performance of the program.
3. Use pprof for performance analysis
The net/http/pprof package in the Go standard library provides a convenient way to analyze the performance of Go programs. We can start an HTTP server by adding some simple code, and then use the pprof tool to obtain and analyze performance data.
import _ "net/http/pprof"
go func() {
(("localhost:6060", nil))
}()
In this example, we started an HTTP server running at localhost:6060. Then we can get the CPU profile through the go tool pprof http://localhost:6060/debug/pprof/profile command, or get the memory profile through the go tool pprof http://localhost:6060/debug/pprof/heap command.
4. Use string stitching
In Go, strings are immutable, which means that each string splicing operation creates a new string. If you need to do a lot of string splicing operations, this can lead to a lot of memory allocation and garbage collection. It is a tool used in Go language for efficient string stitching.
var builder
for i := 0; i < 1000; i++ {
("Hello, World!")
}
result := ()
In this example, we use 1000 string splicing operations. Compared to using + or += directly for string splicing, performance can be significantly improved.
5. Use to avoid goroutine leaks
In Go, if a goroutine is not closed correctly after completing the task, it may keep consuming memory, which is called a goroutine leak. It is a commonly used technique to prevent goroutine leakage.
func doSomethingWithTimeout(timeout ) {
done := make(chan bool)
go func() {
// Do some time-consuming operations... done <- true
}()
select {
case <-done:
// The operation is completed successfully case <-(timeout):
// Operation timeout }
}
In this example, we initiate a goroutine to perform some time-consuming operations, and then use the select statement to wait for the operation to complete or time out. If the operation is completed within the timeout time, the done channel will receive a value and the select statement will exit. If the operation does not complete within the timeout time, a value will be sent, the select statement will exit, and the goroutine will be closed correctly.
6. Use strconv instead of fmt for string conversion
In Go, it is a commonly used method to convert other types of values into strings. However, the performance is generally not as good as the functions in the strconv package.
s := ("%d", 123) // Not recommended
s := (123) // recommendIn this example, we compare two methods of converting integers into strings. Although more flexible, it has better performance.
7. Access tile elements using indexes
In Go, it is common to use range to loop through slices. However, if you only need to access the elements of the slice, and not the index of the elements, accessing elements with indexes will usually have better performance.
for i := range slice {
_ = slice[i] // recommend}
for _, v := range slice {
_ = v // Not recommended}
In this example, we compare two ways to use range loops and access slice elements using indexes. While using range loops is more concise, accessing elements with indexes is better.
8. Avoid creating goroutines in loops
In Go, the go keyword can be used to create a new goroutine. However, if you create goroutines in a loop, it may result in a large number of goroutines being created, thus consuming a lot of memory.
for _, v := range slice {
go func(v int) {
// Process v... }(v)
}
In this example, we create a new goroutine for each element in the loop. While this allows elements to be processed in parallel, if the slice is large in size, it may create a large amount of goroutine, which consumes a lot of memory. Therefore, we should avoid creating goroutines in loops, or use some techniques (such as using or using channels) to limit the number of goroutines.
In the previous articles, we have introduced some common Go language optimization tips. In this article, we will continue to explore more optimization techniques and illustrate them with practical examples.
9. Concurrent and safe mapping operations are used
In Go, the built-in map type is not concurrently safe, which means you cannot read and write the same map in multiple goroutines at the same time. It is a tool in the Go language for concurrent and secure mapping operations.
var m
("hello", "world") // Store key-value pairs
value, ok := ("hello") // Load key-value pairsif ok {
(value)
}
In this example, we use , to store and load key-value pairs. Compared to built-in maps, the performance may be slightly worse, but it can be used safely in multiple goroutines.
10. Use the context package to perform timeout and cancel operations
In Go, the context package provides a mechanism for passing timeouts, cancel signals, and other request range values between API boundaries.
ctx, cancel := ((), )
defer cancel()
select {
case <-(2 * ):
("overslept")
case <-():
(())
}
In this example, we create a context that will automatically cancel after one second. Then we wait for two seconds or context is cancelled. Since context will be cancelled after one second, () will return an error indicating that context has been cancelled.
11. Use the atomic package for concurrent and safe operations
In Go, the sync/atomic package provides some atomic operation functions that can be used to implement concurrent security counters, flags, etc.
var counter int64
go func() {
for {
atomic.AddInt64(&counter, 1)
()
}
}()
go func() {
for {
(atomic.LoadInt64(&counter))
()
}
}()
In this example, we create a concurrently secure counter. One goroutine adds the counter one per millisecond, and the other goroutine prints the current value of the counter every second. Since we use functions from the atomic package, this counter is safe in multiple goroutines.
12. Use reflect package for dynamic operations
In Go, the reflect package provides a mechanism for dynamically operating objects at runtime, including obtaining the type and value of the object, calling methods, etc.
v := (123) t := (123) (()) // Output: 123(()) // Output: int
In this example, we use the reflect package to get the value and type of an integer. Although the reflect package is very powerful, it usually does not perform as well as statically typed operations, so we should use it with caution.
13. Use the sort package for efficient sorting
The Go language sort package provides a series of functions for sorting slices and custom data structures.
nums := []int{3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5}
(nums)
(nums) // Output: [1 1 2 3 3 4 5 5 5 6 9]In this example, we use the function to sort an integer slice. The sort package also provides other functions, such as sort.Float64s, etc., for sorting slices of a specific type.
14. Use the encoding/json package to perform JSON operations
The encoding/json package of Go provides a series of functions for processing JSON data.
type Person struct {
Name string `json:"name"`
Age int `json:"age"`
}
jsonStr := `{"name":"John","age":30}`
var p Person
([]byte(jsonStr), &p)
(p) // Output: {John 30}In this example, we define a Person structure and use the function to parse a JSON string into this structure. The encoding/json package also provides other functions, such as , etc., for converting Go data structures into JSON strings.
The above is the detailed content of the commonly used grammar writing and optimization techniques in Go language. For more information about Go optimization techniques, please pay attention to my other related articles!