Memory usage

Go is a garbage collected environment. This is great for correctness, but it can lead to substantial perf issues. Allocating memory is by no means free and should be done carefully. We want to minimize the occurrence of garbage collection and reduce the amount of work the GC is asked to perform.

Reuse and object pools

Preallocate memory and reuse it over and over again. This not only reduces strain on the GC, it also results in considerably better CPU cache and TLB efficiency which can make your code 10x faster. The Go sync.Pool type can be useful here.

Avoid pointers when you can

Having distinct objects in memory is inherently expensive:

You need at least 8 bytes to point to the object
There is hidden overhead associated with each object (probably between 8 to 16 bytes per object)
Writing to references tends to be more expensive due to GC write barriers
Programmers coming from Java aren’t used to this distinction since Java doesn’t have general support for value types and thus everything is an object and pointers abound. But Go does have good value semantics, so we use them.

So prefer:

  1. type MyContainer struct {
  2. inlineStruct OtherStuff
  3. }

When possible as opposed to:

  1. type MyContainer struct {
  2. outoflineStruct *OtherStruct
  3. }

Avoid creating APIs that require allocations

For example, consider using the second method signature rather than the first one as it avoids potentially large allocations.

No: func (r Reader) Read() ([]byte, error)
Yes: func (r
Reader) Read(buf []byte) (int, error)

About goroutines

Goroutines are said to be cheap, but they need to be used judiciously otherwise performance will suffer.

Don’t create goroutines in the main request serving path. Prefer to create them a priori and have them wait for input.

Measuring

Human beings have proven incapable of predicting the real-world performance of complex systems. Performance tuning should therefore follow the rule of the three Ms:

Measure before doing an optimization
Measure after doing an optimization
Measure continuously as part of every check-in

在go语言中,要避免传递指针因为:
在go里只有只值传递,哪怕是使用指针也是传递的是指针的地址值,定义的结构体不建议使用指针是避免有其他的结构体中也使用了这个地址的数据,就会导致所有使用这种方式的结构体中的数据被修改。这样数据就不是独立的了。

Writing Fast and Lean Code

分类: web

标签:   go