Memory escape analysis

One 、 memory management

There are many ways to manage memory , But from the perspective of the development process , Generally, it is from the independent management of developers （ Manual ） Automatic management of memory to related programs （ Automatically ） Memory . The advantage of manual memory management is that it can control and process the related memory status at any time , But the disadvantage is , The uncontrollable behavior of human beings , In particular, you may forget to recycle memory , This causes a memory leak . This problem rarely occurs in automatic memory management , because GC The memory garbage can be collected regularly or passively . But it also has many problems , For example, the program may be suspended , Low efficiency and so on .
stay GC In the process , Different memory processing mechanisms will lead to the problems analyzed today , Memory escape .

Two 、 Memory escape

In manual memory allocation , Memory specifies where to allocate it . But in the automatic memory management band GC In the program , Something has changed . The compiler will modify the object according to the specific situation （ Variable ） The location of the memory allocation , This process is called memory escape . Make it simpler , If there are some objects that may be allocated on the stack , But the compiler found that it might be overwritten by something else , So adjust it to the heap . such , Its life cycle will grow . conversely , The same is true from heap to stack . Take an example ：

import "fmt"

func Test(ID int) int {
    

	var curID int
	curID = ID

	return curID
}

func main() {
    
	var ID int
	fmt.Println(ID, Test(0))

}

stay Goland Add... To the compilation parameters of -gcflags "-m -l” Or directly input commands in the terminal “go run -gcflags “-m -l” main.go”
The running result is ：

# command-line-arguments
.\main.go:25:13: ... argument does not escape
.\main.go:25:13: ID escapes to heap
.\main.go:25:22: Test(0) escapes to heap

You can see that the related memory escapes are explained , If you are interested, you can test some examples according to the actual situation .

3、 ... and 、 Escape analysis

Let's analyze the specific situation of escape , First of all, determine the rules of escape judgment ：
1、 If there is no reference outside the function , Is placed on the stack first ;
2、 If there is a reference outside the function , Put it in the heap ;
3、 If there is no room on the stack , Will be put on the heap
Let's take a look at the specific scene of the escape ：
1、 The pointer escaped
2、 Insufficient stack space to escape
3、 Dynamic type escape
4、 Closure reference object escape
Generally speaking , Allocating space on the stack is more efficient and safer than allocating space on the heap , And the memory of the stack is automatically managed by the system, so it is unnecessary GC, The memory allocated on the heap requires GC, But I have analyzed it before , The so-called escape , In fact, it is to analyze whether stack memory conversion is performed at the compilation stage .
But in the actual application process , There are some typical examples of memory escape ： For example, a function returns a pointer to a local variable ; To send a pointer or data containing a pointer to a channel ; Storing pointers or objects containing pointers on slices ; Expanded allocation of the underlying array of slices ; Call method on interface type ; Not enough stack space ; Yes map Assign pointer type objects, etc .
So what does memory escape do ？
1、 Memory escape can be reduced GC The pressure of the , Only those who escape to the heap GC.
2、 Memory escape analysis can identify the location of variables and determine efficiency .
3、 For threads , It can reduce the synchronization complexity and improve the operation efficiency . After escape analysis , If there is no multi-threaded operation, the lock and related synchronization mechanism in the thread will be automatically cancelled .

Four 、 summary

Doing computer software , In fact, it is nothing more than a few questions .CPU（ Multithreading 、 Multi process, etc ）、 Memory （ Small cost, big result ）、IO（ As fast as possible 、 Safety, etc ）, Network communication （ Distributed, etc ）, Not that other problems are not problems , But the most important ones are these , Among them, the most annoying thing , Memory management is definitely a top priority （ I can't help it if I don't recognize it ）. In fact, I wrote too much code , You'll find out , Memory is the first enemy , Others sometimes have a day , The only problem is memory , Always with me .
Want to write robust code , We should take a careful look at how to manage the memory , Especially when you write your own code . Don't think you have GC, All is well , otherwise , It's going to be ugly .