Cara memantau golang gc

Dengan perkembangan bahasa Go, mekanisme kutipan sampah semakin matang. Mekanisme pengumpulan sampah Go dicapai dengan mengesan pengiraan rujukan memori. Dalam sesetengah kes, kutipan sampah yang terlalu kerap atau terlalu memakan masa boleh menjejaskan prestasi aplikasi dengan serius. Oleh itu, kita perlu memantau dan mengoptimumkan mekanisme pengumpulan sampah dalam bahasa Go. Dalam artikel ini, kami akan memperkenalkan cara menggunakan alat pemantauan bahasa Go sendiri dan alat pihak ketiga untuk memantau dan mengoptimumkan mekanisme pengumpulan sampah.

Alat pemantauan bahasa Go sendiri

Bahasa Go menyediakan pembangun dengan beberapa alat pemantauan yang sangat berguna, yang membolehkan kami memantau status aplikasi yang sedang berjalan dengan lebih mudah. Antara alat pemantauan ini, yang utama berkaitan dengan kutipan sampah adalah seperti berikut:

1. pakej runtime/debug

pakej runtime/debug menyediakan beberapa alatan yang boleh digunakan untuk semak dan maklumat penyahpepijatan masa jalan untuk menyahpepijat program Go. Antaranya, fungsi yang paling biasa digunakan ialah FreeOSMemory(), yang memberitahu pengumpul sampah untuk cuba menuntut semula memori yang diduduki oleh sistem pengendalian itu sendiri. Fungsi ini berguna untuk aplikasi yang kerap menggunakan jumlah memori yang besar. Pada masa yang sama, pakej nyahpepijat juga menyediakan fungsi untuk mendapatkan maklumat berkaitan GC:

• SetGCPercent(percent int) int: digunakan untuk menetapkan kekerapan pelaksanaan GC. Nilai lalai ialah $GOGC=100, yang bermaksud kutipan sampah bermula apabila saiz timbunan meningkat sebanyak 100%. Jika anda memerlukan pengumpulan sampah yang lebih kerap, anda boleh menetapkan nilai yang lebih kecil, seperti $GOGC=50.
• SetMaxStack(depth int) int: digunakan untuk menetapkan kedalaman tindanan maksimum.
• SetMaxThreads(num int) int: digunakan untuk menetapkan bilangan maksimum utas dalam program Go.
• ReadGCStats(stats *GCStats): digunakan untuk mendapatkan maklumat statistik berkaitan GC.

2. pakej runtime/pprof

Pakej masa jalan/pprof menyediakan alatan analisis prestasi untuk program Go, yang boleh membantu kami mengenal pasti kesesakan dan mengoptimumkannya. Alat analisis prestasi bahasa Go boleh mengeluarkan fail dalam format yang berbeza yang biasa digunakan ialah:

• Pemprofilan CPU: Memaparkan overhed CPU; >
Pemprofilan Sekat: Menunjukkan situasi menyekat;
• Pemprofilan Goroutine: Menunjukkan status Goroutine (coroutine).
• Amat mudah untuk menggunakan pakej pprof untuk menyemak penunjuk berkaitan GC dalam program Go, seperti kod berikut:

pakej log

import (
    "net/http"
    _ "net/http/pprof"
)

func main() {
    // start web server to listen on localhost:8080
    go func() {
        http.ListenAndServe("localhost:8080", nil)
    }()

    // do something...

    // run heap profiling
    http.DefaultServeMux.HandleFunc("/debug/pprof/heap", func(w http.ResponseWriter, r *http.Request) {
        pprof.Lookup("heap").WriteTo(w, 2)
    })
}

3. Pakej log ialah pakej yang digunakan untuk log masuk ke perpustakaan standard bahasa Go. Apabila menganalisis prestasi GC, kami boleh menggunakan pakej log untuk merekodkan sejarah berjalan sistem. Log ini boleh membantu kami menganalisis gelagat kutipan sampah, cara mengoptimumkan mekanisme kutipan sampah, dsb.

Alat pemantauan GC pihak ketiga

Selain alatan pemantauan yang disertakan dengan bahasa Go, terdapat juga beberapa alatan pihak ketiga yang boleh membantu kami memantau, menganalisis dan mengoptimumkan GC dengan lebih baik -situasi yang berkaitan. Tiga alatan berikut ialah yang kami cadangkan:

Prometheus dan Grafana

1. Prometheus ialah alat untuk memantau pelbagai aplikasi, dan ia boleh membantu mengumpul aplikasi pelbagai maklumat pemantauan dan menyimpan ia dalam pangkalan data, membolehkan analisis yang lebih mendalam. Grafana menyediakan alat visualisasi data untuk memaparkan pelbagai data yang dikumpul dengan lebih jelas. Metrik berkaitan GC berikut boleh dikumpulkan menggunakan Prometheus dan Grafana:

go_gc_duration_seconds

go_gc_cpu_fraction
• go_gc_deltas_alloc_bytes
• go_>
go_gc_alloc_bytes go_gc_pause_ns_avg
• go_gc_pause_ns_max
• go_gc_pause_ns_min
• go_gc_pause_ns_total
• go_gc_pause_ns_min
• go_gc_pause_ns_total

net 🎜>Semasa dalam Bahasa Go Pakej ini telah disebut dalam alat pemantauan terbina dalam, tetapi perkara yang ingin kami tekankan di sini ialah ringkasan maklumat yang disediakannya, yang boleh membantu kami memahami operasi GC dengan lebih baik, contohnya:

• AllocSpace: status peruntukan memori;
• Timbunan: status peruntukan ruang;
• MSpan: status peruntukan memori luar timbunan;
• Scavenge: status pembersihan memori;
• Sapu: Maklumat kutipan sampah.

3. gopsutil

gopsutil ialah pustaka bahasa Go yang digunakan untuk mengumpul maklumat sistem. Ia boleh mengumpul sejumlah besar maklumat sistem, termasuk CPU, memori, cakera keras, rangkaian, dll. Kita boleh menggunakan fungsi MemoryStat dalam gopsutil untuk menganalisis penggunaan memori sistem dan melihat program atau Goroutine yang mengambil terlalu banyak memori.

Kesimpulan

Semasa proses pembangunan, adalah sangat penting untuk memantau mekanisme kutipan sampah dalam bahasa Go. Kami boleh menggunakan alatan pemantauan yang disertakan dengan bahasa Go, seperti pakej nyahpepijat, pakej pprof dan pakej log Mereka menyediakan beberapa fungsi dan antara muka yang berguna untuk memudahkan kami memahami gelagat GC. Selain itu, kami juga boleh menggunakan beberapa alat pihak ketiga, seperti Prometheus, Grafana dan gopsutil, yang menyediakan sistem pemantauan yang lebih lengkap dan boleh memberikan kami analisis data dan visualisasi data yang lebih terperinci. Secara umumnya, untuk pemantauan dan pengoptimuman kutipan sampah, perlu bermula dari pelbagai aspek dan mencari strategi GC yang optimum melalui eksperimen dan analisis berterusan untuk mencapai prestasi dan kestabilan aplikasi yang terbaik.

Atas ialah kandungan terperinci Cara memantau golang gc. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!