Let’s talk about several major issues of GC in Go language

In recent years, the Go language has become more and more popular, and the GC mechanism is also widely praised in the industry. However, every technology has its shortcomings and shortcomings, and the GC of the Go language is no exception. This article will discuss several major issues with Go language GC and introduce the improvements and optimizations implemented by the Go team from Go 1.5 to Go 1.12.

Go Language GC Mechanism Analysis

First of all, let’s take a look at the GC mechanism of Go language.

In the Go language, the GC mechanism is implemented by the runtime module. The GC traverses the program's object graph, marking all objects that are still in use, and clearing unreferenced objects. During this process, the running program will be suspended.

The GC mechanism is a major feature of the Go language. It can avoid many memory problems, such as memory leaks, wild pointers, etc. But at the same time, it also brings some performance issues, especially in large systems. Below, we list common GC problems one by one.

Common GC problems

1. The program pauses during GC.

When the GC is running, it pauses the entire program. This problem does not cause much impact in small-scale programs. But for large programs that require high concurrent processing, GC pauses may lead to performance degradation and increased latency, thus affecting user experience.

2. GC overhead is high.

GC needs to traverse the entire object graph, thus consuming a lot of CPU and memory resources. When the object graph is very complex, the overhead of GC increases significantly.

3. GC jitter occurs.

Jitter refers to the situation where GC is performed multiple times within a time interval. When the GC performs a long marking phase, the program cannot respond to requests, causing delays or even crashes. This problem is particularly common in systems with high concurrent requests.

4. GC will preempt program execution.

The garbage collector will seize the execution right of the program when recycling. If a program's execution rights are occupied by the garbage collector for a long time, it may cause serious performance problems.

GC improvements from Go 1.5 to Go 1.12

In order to solve these problems, the Go team has made various GC improvements in Go 1.5 to Go 1.12. The specific improvements are as follows:

1. Three-color marking algorithm

The three-color marking algorithm is an optimized GC algorithm that can optimize the pause of program running time during GC execution. This algorithm minimizes program pause times and reduces jitter problems.

In Go 1.5 version, the garbage collector uses a three-color marking algorithm, which greatly reduces GC pause time and CPU overhead. Subsequent versions have made continuous improvements and optimizations on this basis, improving overall performance and stability.

2. Concurrent Marking

Go 1.5 version also introduced the concurrent marking feature, which is performed during the marking phase of the garbage collector. This marking method can be executed at the same time as the program is running, thereby reducing GC pause time.

In the new tag, objects will be marked as "used" or "unused", which can greatly reduce the time required for concurrent tags. This marking method can significantly reduce jitter and in some cases eliminate it entirely.

3. Improve heap processing

GC needs to check the objects in the heap, therefore, the structure of the heap has a great impact on performance. The Go team began optimizing the heap processing algorithm in Go 1.5, which included reducing heap fragmentation. This improvement greatly improves the execution efficiency of GC.

4. Treat large objects better

For a large number of large objects, because they will significantly affect the efficiency of GC, they need special treatment. In past versions, large objects were classified as persistent objects and had special GC handling enabled. But in Go 1.8 version, large objects are classified into the "black list", and the GC will use this list to determine which large objects require special processing.

5. Automatically adjust GC parameters

In previous versions, Go programmers needed to manually adjust GC parameters, such as GC execution speed and GC threshold. But in Go 1.8 version, Go supports automatic adjustment of GC parameters, which can automatically balance GC execution efficiency and interruption between large objects and small objects. Versions after

have continuously optimized and improved this mechanism.

Summary

This article introduces the GC mechanism in the Go language and a series of problems that may be caused by the GC mechanism. At the same time, in order to solve these problems, the Go team has made various GC improvements in Go 1.5 to Go 1.12, including three-color marking algorithm, concurrent marking, improved heap processing, better treatment of large objects, and automatic adjustment of GC parameters. wait. These improvements have greatly improved the performance and stability of GC, making the Go language even better at handling large systems.

The above is the detailed content of Let’s talk about several major issues of GC in Go language. For more information, please follow other related articles on the PHP Chinese website!