Apa itu Garbage Collector ?
Garbage Collection (Pengumpulan sampah digital) adalah proses mengosongkan ruang memori yang tidak digunakan. Dengan kata lain, Garbage Collector melihat objek mana yang berada di luar cakupan dan tidak dapat direferensikan lagi serta membebaskan ruang memori yang mereka konsumsi.
Proses ini terjadi secara bersamaan saat program Go berjalan dan bukan sebelum atau sesudah eksekusi program.
Akan tetapi, kekhawatiran utama dari Garbage Collector Go adalah latensinya yang rendah, yang pada dasarnya berarti jeda singkat dalam pengoperasiannya agar dapat beroperasi secara real-time.
Di sisi lain, apa yang dilakukan program adalah membuat objek baru dan memanipulasi objek yang ada dengan pointer sepanjang waktu. Proses ini akhirnya dapat membuat objek yang tidak dapat diakses lagi karena tidak ada penunjuk yang menunjuk ke objek tersebut.
Objek ini kemudian menjadi sampah dan menunggu Garbage Collector (pengumpul sampah) membersihkannya dan mengosongkan ruang memori mereka. Setelah itu, ruang memori yang telah dibebaskan siap digunakan kembali.
Implementasi Fitur Garbage Collector di GoLang
Pustaka standar (Library) Go menawarkan fungsi yang memungkinkan kamu mempelajari operasi Garbage Collector dan mempelajari lebih lanjut tentang apa yang dilakukan mereka. Kode yang relevan disimpan sebagai gColl.go dan akan disajikan dalam tiga bagian.
Segmen kode pertama gColl.go adalah sebagai berikut:
package main
import (
“fmt”
“runtime”
“time”
)
func printStats(mem runtime.MemStats) {
runtime.ReadMemStats(&mem)
fmt.Println(“mem.Alloc:”, mem.Alloc)
fmt.Println(“mem.TotalAlloc:”, mem.TotalAlloc)
fmt.Println(“mem.HeapAlloc:”, mem.HeapAlloc)
fmt.Println(“mem.NumGC:”, mem.NumGC)
fmt.Println(“—–“)
}
Perhatikan bahwa setiap kali kamu ingin mendapatkan statistik Garbage Collector terbaru, kamu perlu memanggil fungsi runtime.ReadMemStats (). Tujuan dari fungsi printStats () adalah untuk menghindari penulisan kode Go yang sama sepanjang waktu.
Bagian kedua dari program ini adalah sebagai berikut :
func main() {
var mem runtime.MemStats
printStats(mem)
for i := 0; i < 10; i++ {
s := make([]byte, 50000000)
if s == nil {
fmt.Println(“Operation failed!”)
}
}
printStats(mem)
Loop for membuat banyak irisan Go (Go Slices) yang besar untuk mengalokasikan sejumlah besar memori dan memicu Garbage Collector.
Bagian terakhir gColl.go hadir dengan kode Go berikutnya, yang melakukan lebih banyak alokasi memori menggunakan Go Slice :
for i := 0; i < 10; i++ {
s := make([]byte, 100000000)
if s == nil {
fmt.Println(“Operation failed!”)
}
time.Sleep(5 * time.Second)
}
printStats(mem)
}
Berikut tampilan output gColl.go di mesin macOS Mojave:
$ go run gColl.go
mem.Alloc: 66024
mem.TotalAlloc: 66024
mem.HeapAlloc: 66024
mem.NumGC: 0
—–
mem.Alloc: 50078496
mem.TotalAlloc: 500117056
mem.HeapAlloc: 50078496
mem.NumGC: 10
—–
mem.Alloc: 76712
mem.TotalAlloc: 1500199904
mem.HeapAlloc: 76712
mem.NumGC: 20
—–
Meskipun kamu tidak akan memeriksa pengoperasian Garbage Collector Go sepanjang waktu, kemampuan untuk mengamati cara kerjanya pada aplikasi yang lambat dapat menghemat banyak waktu dalam jangka panjang.
Ada trik yang memungkinkan kamu mendapatkan keluaran yang lebih detail tentang cara kerja Garbage Collector Go, yang diilustrasikan dalam perintah berikut :
$ GODEBUG=gctrace=1 go run gColl.go
Kalau kamu meletakkan GODEBUG = gctrace = 1 di depan sembarang perintah pada go run, Go akan mencetak data analitik tentang operasi Garbage Collector. Data tersebut akan berupa :
gc 4 @0.025s 0%: 0.002+0.065+0.018 ms clock,
0.021+0.040/0.057/0.003+0.14 ms cpu, 47->47->0 MB, 48 MB goal, 8 P
gc 17 @30.103s 0%: 0.004+0.080+0.019 ms clock,
0.033+0/0.076/0.071+0.15 ms cpu, 95->95->0 MB, 96 MB goal, 8 P$
Bergantung pada persyaratan sistem, trinitas nilai mungkin berbeda. Misalnya, nilai trinitas 47-> 47-> 0 MB dari keluaran sebelumnya memberi kita lebih banyak informasi tentang ukuran heap selama proses Garbage Collector.
Angka pertama adalah ukuran heap saat pengumpul sampah akan dijalankan. Nilai kedua adalah ukuran heap saat Garbage Collector mengakhiri operasinya. Nilai terakhir adalah ukuran heap aktif.
Sumber : https://hub.packtpub.com/implementing-memory-management-with-golang-garbage-collector/
