pprof ialah alat analisis prestasi Go Semasa program berjalan, ia boleh merekodkan maklumat berjalan program, yang boleh menjadi penggunaan CPU, penggunaan memori, status berjalan goroutine, dll. Apabila penalaan prestasi atau pepijat. pengesanan diperlukan, Ada kalanya, maklumat yang direkodkan ini agak penting. Terdapat banyak cara untuk menggunakan pprof Go telah membungkus "net/http/pprof".
Persekitaran pengendalian tutorial ini: sistem Windows 7, GO versi 1.18, komputer Dell G3.
profil biasanya dipanggil analisis prestasi Terjemahan dalam kamus ialah gambaran keseluruhan (kata nama) atau gambaran keseluruhan yang menerangkan ... kata kerja). Untuk program komputer, profilnya ialah pelbagai maklumat umum tentang program semasa ia dijalankan, termasuk penghunian CPU, memori, status benang, penyekatan benang, dsb. Mengetahui maklumat tentang program ini, anda boleh mencari masalah dan punca kegagalan dalam program dengan mudah.
pprof ialah alat analisis prestasi Go Semasa program berjalan, ia boleh merekodkan maklumat berjalan program, yang boleh menjadi penggunaan CPU, penggunaan memori, status berjalan goroutine, dll. Apabila penalaan prestasi atau pepijat. lokasi diperlukan, Ada kalanya, maklumat yang direkodkan ini agak penting.
golang mempunyai sokongan yang lebih baik untuk pemprofilan Pustaka standard menyediakan perpustakaan profil "runtime/pprof" dan "net/http/pprof", dan juga menyediakan banyak alat visual yang berguna untuk membantu pembangun.
Untuk perkhidmatan dalam talian, untuk Pelayan HTTP, akses antara muka HTTP yang disediakan oleh pprof untuk mendapatkan data prestasi. Sudah tentu, sebenarnya, lapisan bawah di sini juga memanggil fungsi yang disediakan oleh runtime/pprof, yang dirangkumkan ke dalam antara muka untuk menyediakan akses rangkaian luaran Artikel ini terutamanya memperkenalkan penggunaan "net/http/pprof".
Terdapat banyak cara untuk menggunakan pprof Go telah membungkus satu: net/http/pprof, yang mudah untuk digunakan gunakan. Dengan beberapa baris arahan, anda boleh memulakan pprof, merekodkan maklumat yang sedang berjalan, dan menyediakan perkhidmatan web yang boleh mendapatkan data berjalan melalui pelayar dan baris arahan.
Bagaimana untuk membolehkan pemantauan dalam perkhidmatan web, mari lihat contoh mudah.
package main
import (
"fmt"
"net/http"
_ "net/http/pprof"
)
func main() {
// 开启pprof，监听请求
ip := "0.0.0.0:8080"
if err := http.ListenAndServe(ip, nil); err != nil {
fmt.Printf("start pprof failed on %s\n", ip)
}
dosomething()
}Import pakej "net/http/pprof" ke dalam program dan buka port mendengar Pada masa ini, anda boleh mendapatkan profil program Dalam pengeluaran sebenar, kami biasanya merangkumkan fungsi ini ke dalam goroutine. Jadi bagaimana anda menyemaknya selepas membukanya? Terdapat tiga cara:
Buka penyemak imbas dan masukkan ip:port/debug/pprof, Masuk.
pprof akan memberikan banyak data prestasi. Maksud khusus ialah:
allocs ialah peruntukan memori semua objek, dan heap ialah peruntukan memori objek aktif , yang akan diterangkan secara terperinci kemudian.
1 Apabila analisis prestasi CPU didayakan, masa jalan Go akan menjeda setiap 10ms untuk merekodkan tindanan panggilan dan data berkaitan goroutine yang sedang berjalan. Selepas data analisis prestasi disimpan ke cakera keras, kita boleh menganalisis titik panas dalam kod.
2. Analisis prestasi memori adalah untuk merekodkan timbunan panggilan apabila timbunan diperuntukkan. Secara lalai, ia dijadikan sampel sekali setiap 1000 peruntukan, nilai ini boleh diubah. Peruntukan tindanan tidak akan direkodkan oleh analisis memori kerana ia akan dikeluarkan pada bila-bila masa. Kerana analisis memori adalah kaedah pensampelan, dan juga kerana ia merekodkan peruntukan memori, bukan penggunaan memori. Oleh itu, adalah sukar untuk menggunakan alat analisis prestasi ingatan untuk menentukan dengan tepat penggunaan memori khusus sesuatu program.
3. Analisis sekatan ialah analisis yang sangat unik Ia agak serupa dengan analisis prestasi CPU, tetapi apa yang direkodkan ialah masa yang diluangkan oleh goroutine menunggu sumber. Analisis penyekatan sangat membantu dalam menganalisis kesesakan konkurensi program Analisis prestasi menyekat boleh ditunjukkan apabila sejumlah besar goroutin disekat. Analisis prestasi menyekat ialah alat analisis khas dan tidak boleh digunakan untuk analisis sebelum CPU dan kesesakan memori telah dihapuskan.
Sudah tentu, jika anda mengklik mana-mana pautan, anda akan mendapati bahawa kebolehbacaan adalah lemah dan hampir mustahil untuk dianalisis. Seperti yang ditunjukkan dalam gambar:
Klik timbunan dan tatal ke bawah Anda boleh melihat beberapa data menarik, yang kadangkala boleh membantu untuk menyelesaikan masalah, tetapi biasanya tidak digunakan.
heap profile: 3190: 77516056 [54762: 612664248] @ heap/1048576 1: 29081600 [1: 29081600] @ 0x89368e 0x894cd9 0x8a5a9d 0x8a9b7c 0x8af578 0x8b4441 0x8b4c6d 0x8b8504 0x8b2bc3 0x45b1c1 # 0x89368d github.com/syndtr/goleveldb/leveldb/memdb.(*DB).Put+0x59d # 0x894cd8 xxxxx/storage/internal/memtable.(*MemTable).Set+0x88 # 0x8a5a9c xxxxx/storage.(*snapshotter).AppendCommitLog+0x1cc # 0x8a9b7b xxxxx/storage.(*store).Update+0x26b # 0x8af577 xxxxx/config.(*config).Update+0xa7 # 0x8b4440 xxxxx/naming.(*naming).update+0x120 # 0x8b4c6c xxxxx/naming.(*naming).instanceTimeout+0x27c # 0x8b8503 xxxxx/naming.(*naming).(xxxxx/naming.instanceTimeout)-fm+0x63 ...... # runtime.MemStats # Alloc = 2463648064 # TotalAlloc = 31707239480 # Sys = 4831318840 # Lookups = 2690464 # Mallocs = 274619648 # Frees = 262711312 # HeapAlloc = 2463648064 # HeapSys = 3877830656 # HeapIdle = 854990848 # HeapInuse = 3022839808 # HeapReleased = 0 # HeapObjects = 11908336 # Stack = 655949824 / 655949824 # MSpan = 63329432 / 72040448 # MCache = 38400 / 49152 # BuckHashSys = 1706593 # GCSys = 170819584 # OtherSys = 52922583 # NextGC = 3570699312 # PauseNs = [1052815 217503 208124 233034 ......] # NumGC = 31 # DebugGC = false
除了浏览器，Go还提供了命令行的方式，能够获取以上信息，这种方式用起来更方便。
使用命令go tool pprof url可以获取指定的profile文件，此命令会发起http请求，然后下载数据到本地，之后进入交互式模式，就像gdb一样，可以使用命令查看运行信息，以下为使用示例：
# 下载cpu profile，默认从当前开始收集30s的cpu使用情况，需要等待30s go tool pprof http://localhost:8080/debug/pprof/profile # 30-second CPU profile go tool pprof http://localhost:8080/debug/pprof/profile?seconds=120 # wait 120s # 下载heap profile go tool pprof http://localhost:8080/debug/pprof/heap # heap profile # 下载goroutine profile go tool pprof http://localhost:8080/debug/pprof/goroutine # goroutine profile # 下载block profile go tool pprof http://localhost:8080/debug/pprof/block # goroutine blocking profile # 下载mutex profile go tool pprof http://localhost:8080/debug/pprof/mutex
接下来用一个例子来说明最常用的四个命令：web、top、list、traces。
接下来以内存分析举例，cpu和goroutine等分析同理，读者可以自行举一反三。
首先，我们通过命令go tool pprof url获取指定的profile/heap文件，随后自动进入命令行。如图：
第一步，我们首先输入web命令，这时浏览器会弹出各个函数之间的调用图，以及内存的之间的关系。如图：
这个图的具体读法，可参照：中文文档 或者英文文档 这里不多赘述。只需要了解越红越大的方块，有问题的可能性就越大，代表可能占用了更多的内存，如果在cpu的图中代表消耗了更多cpu资源，以此类推。
接下来 top、list、traces三步走可以看出很多想要的结果。
top 按指标大小列出前10个函数，比如内存是按内存占用多少，CPU是按执行时间多少。
top会列出5个统计数据：
cum%: 是累计量占总量的百分比。
这样我们可以看到到底是具体哪些函数占用了多少内存。
当然top后也可以接参数，top n可以列出前n个函数。
list可以查看某个函数的代码，以及该函数每行代码的指标信息，如果函数名不明确，会进行模糊匹配，比如list main会列出main.main和runtime.main。现在list sendToASR试一下。
可以看到切片中增加元素时，占用了很多内存，左右2个数据分别是flat和cum。
traces 打印所有调用栈，以及调用栈的指标信息。使用方式为traces+函数名（模糊匹配）。
在命令行之中，还有一个重要的参数 -base，假设我们已经通过命令行得到profile1与profile2,使用go tool pprof -base profile1 profile2，便可以以profile1为基础，得出profile2在profile1之上出现了哪些变化。通过两个时间切片的比较，我们可以清晰的了解到，两个时间节点之中发生的变化，方便我们定位问题（很重要！！！！）
打开可视化界面的方式为：go tool pprof -http=:1234 http://localhost:8080/debug/pprof/heap 其中1234是我们指定的端口
Top
该视图与前面所讲解的 top 子命令的作用和含义是一样的，因此不再赘述。
Graph
为函数调用图，不在赘述.
Intai
Berbanding dengan paparan Atas, paparan ini menambah paparan maklumat kontekstual, yang merupakan output fungsi .
Sumber
Paparan ini terutamanya menambah penjejakan dan analisis untuk kod sumber Anda boleh melihat bahawa overhednya digunakan terutamanya di tempat .
Graf Nyala
Graf nyalaan yang sepadan dengan penggunaan sumber Bacaan graf nyalaan tidak akan diterangkan di sini bukan fokus artikel ini.
Menu lungsur turun kedua adalah seperti yang ditunjukkan dalam rajah:
alloc_objects,alloc_space mewakili sumber yang diperuntukkan oleh aplikasi, sama ada dikeluarkan atau tidak, inuse_objects,inuse_space Menunjukkan peruntukan sumber yang belum dikeluarkan oleh aplikasi.
| Name | Meaning |
|---|---|
| inuse_space | amount of memory allocated and not released yet |
| inuse_objects | amount of objects allocated and not released yet |
| alloc_space | total amount of memory allocated (regardless of released) |
| alloc_objects | total amount of objects allocated (regardless of released) |
第一个下拉菜单可以与第二个下拉菜单相组合，可以查看临时变量的火焰图，常驻变量的内存调用图等。
tips：
上面我们已经看完了go pprof 的所有操作，接下来讲解一下go tool pprof 的具体使用流程。
go tool pprof -base比较两个不同时间点的状态更方便我们定位问题。启动程序后，用浏览器方式打开profile:
发现内存持续上升，同时goroutine也在持续上升，初步判断，内存泄漏是由于goroutine泄漏导致的。
接下来通过命令行方式抓取goroutine的情况：命令行输入：go tool pprof localhost:8080/debug/pprof/goroutine，获取结果。
一、使用web命令查看调用图，大概了解目前的goroutine的泄露情况：
通过观察，最引入注目的便是runtime.gopark这个函数，这个函数在所有goroutine泄漏时都会出现，并且是大头，接下来我们研究一下这个函数的作用:
func gopark(unlockf func(*g, unsafe.Pointer) bool, lock unsafe.Pointer, reason waitReason, traceEv byte, traceskip int) {
mp := acquirem()
gp := mp.curg
status := readgstatus(gp)
mp.waitlock = lock
mp.waitunlockf = unlockf
gp.waitreason = reason
mp.waittraceev = traceEv
mp.waittraceskip = traceskip
releasem(mp)
mcall(park_m)
}该函数的作用为：
1、调用acquirem函数：获取当前goroutine所绑定的m，设置各类所需参数。调用 releasem 函数将当前 goroutine 和其 m 的绑定关系解除。
2、调用 park_m 函数：将当前 goroutine 的状态从 _Grunning 切换为 _Gwaiting，也就是等待状态。删除 m 和当前 goroutine m→curg（简称gp）之间的关联。
3、调用 mcall 函数，仅会在需要进行 goroutiine 切换时会被调用：切换当前线程的堆栈，从 g 的堆栈切换到 g0 的堆栈并调用 fn(g) 函数。将 g 的当前 PC/SP 保存在 g->sched 中，以便后续调用 goready 函数时可以恢复运行现场。
综上：该函数的关键作用就是将当前的 goroutine 放入等待状态，这意味着 goroutine 被暂时被搁置了，也就是被运行时调度器暂停了。
所以出现goroutine泄漏一定会调用这个函数，这个函数不是goroutine泄漏的原因，而是goroutine泄漏的结果。
此外，我们发现有两个函数的goroutine的达到了67，很可疑，在我们接下来的验证中要格外留意。
二、使用top命令，获取更加具体的函数信息：
与上面分析的结论相似，我们要将关注点放在三个开启了67个goroutine的函数。
三、traces+函数名，查看调用栈，这一步在函数调用很复杂，无法从调用图里面清晰的看出时使用，帮助我们更清晰的了解函数的调用堆栈：
四、使用list+函数名，查看具体代码的问题。
通过list命令我们可以清楚的看出问题代码是堵塞在哪里。接下来的篇幅我们来分析一下这个问题：
什么是goroutine泄漏：如果你启动了一个 goroutine，但并没有符合预期的退出，直到程序结束，此goroutine才退出，这种情况就是 goroutine 泄露。当 goroutine 泄露发生时，该 goroutine 的栈(一般 2k 内存空间起)一直被占用不能释放，goroutine 里的函数在堆上申请的空间也不能被 垃圾回收器 回收。这样，在程序运行期间，内存占用持续升高，可用内存越来也少，最终将导致系统崩溃。
什么时候出现goroutine泄漏：goroutine泄露一般是因为channel操作阻塞而导致整个routine一直阻塞等待或者 goroutine 里有死循环。
具体细分一下：
select底层也是channel实现的，如果所有case上的操作阻塞，select内部的channel便会阻塞，goroutine也无法继续执行。所以我们使用channel时一定要格外小心。
通过分析上面两幅图的情况，可以判断是因为select在所有case上死锁了，再深入代码分析，是因为项目中的的语音模型并发能力弱，在语音发包速度快起来的时候无法处理，导致select不满足条件，导致goroutine泄漏,应该在for循环之外加一个asr←nil，保证func2的select一定会满足，同时提高模型的并发能力，使得func1的不会阻塞。
防止goroutine泄漏的建议：
我们通过grafana发现内存出现泄漏：
这一次我们不使用命令行，而是使用图形化界面来定位问题。
输入 go tool pprof -http=:1234 localhost:8080/debug/pprof/heap:
发现内存占用很有可能是byte.makeSlice()导致的，火焰图看的更加清晰：
而调用byte.makeSlice()的函数为标准库中的ioutil.ReadAll()，接下来我们只需要研究这个标准库函数的实现即可。
func readAll(r io.Reader, capacity int64) (b []byte, err error) {
buf := bytes.NewBuffer(make([]byte, 0, capacity))
defer func() {
e := recover()
if e == nil {
return
}
if panicErr, ok := e.(error); ok && panicErr == bytes.ErrTooLarge {
err = panicErr
} else {
panic(e)
}
}()
_, err = buf.ReadFrom(r)
return buf.Bytes(), err
}
// bytes.MinRead = 512
func ReadAll(r io.Reader) ([]byte, error) {
return readAll(r, bytes.MinRead)
}可以看到 ioutil.ReadAll 每次都会分配初始化一个大小为 bytes.MinRead 的 buffer ，bytes.MinRead 在 Golang 里是一个常量，值为 512 。就是说每次调用 ioutil.ReadAll 都先会分配一块大小为 512 字节的内存。
接下来看一下ReadFrom函数的实现：
func (b *Buffer) ReadFrom(r io.Reader) (n int64, err error) {
b.lastRead = opInvalid
// If buffer is empty, reset to recover space.
if b.off >= len(b.buf) {
b.Truncate(0)
}
for {
if free := cap(b.buf) - len(b.buf); free < MinRead {
// not enough space at end
newBuf := b.buf
if b.off+free < MinRead {
// not enough space using beginning of buffer;
// double buffer capacity
newBuf = makeSlice(2*cap(b.buf) + MinRead)
}
copy(newBuf, b.buf[b.off:])
b.buf = newBuf[:len(b.buf)-b.off]
b.off = 0
}
m, e := r.Read(b.buf[len(b.buf):cap(b.buf)])
b.buf = b.buf[0 : len(b.buf)+m]
n += int64(m)
if e == io.EOF {
break
}
if e != nil {
return n, e
}
}
return n, nil // err is EOF, so return nil explicitly
}ReadFrom函数主要作用就是从 io.Reader 里读取的数据放入 buffer 中，如果 buffer 空间不够，就按照每次 2x + MinRead 的算法递增，这里 MinRead 的大小也是 512 Bytes 。
项目读取的音频文件一般很大，buffer不够用，会一直调用makeSlice扩容，消耗大量内存，但是仅仅这样，只是程序执行时消耗了比较多的内存，并未有内存泄露的情况，那服务器又是如何内存不足的呢？这就不得不扯到 Golang 的 GC 机制。
GC算法的触发时机
golang的GC算法为三色算法，按理说会回收临时变量，但是触发GC的时机导致了这个问题：
ioutil.ReadAll会将全部的数据加载到内存,一个大请求会多次调用makeSlice 分配很多内存空间，并发的时候，会在很短时间内占用大量的系统内存，然后将 GC 阈值增加到一个很高的值，这个时候要 GC 就只有等 2 分钟一次的强制 GC。这样内存中的数据无法及时GC，同时阈值还在不停的升高，导致GC的效率越来越低，最终导致缓慢的内存泄漏。
解决方法
//req.AduioPack,err=ioutil.ReadAll(c.Resquest.Body) buffer:=bytes.NewBuffer(make[]byte,0,6400) _,err:=io.Copy(buffer,c.Resquest.Body) temp:=buffer.Bytes() req.AduioPack=temp
不是一次性把文件读入内存，而是申请固定的内存大小。
[Cadangan berkaitan: Pergi tutorial video, Pengajaran pengaturcaraan]
Atas ialah kandungan terperinci apa itu go pprof. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!
Penggunaan kata kunci Jenis dalam Go
Cara melaksanakan senarai terpaut dalam go
Apakah perisian pengaturcaraan bahasa Go?
Bagaimana untuk belajar bahasa go dari 0 asas
Bagaimana untuk menentukan pembolehubah dalam golang
Apakah kaedah untuk melaksanakan lebihan beban operator dalam bahasa Go?
Apakah pengendali dalam bahasa Go?
Apakah kaedah penukaran data dalam golang?
![[Web front-end] Permulaan pantas Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
