Mengenal Package Context With Timeout Pada Golang

Pengenalan package context.WithTimeout

Pada artikel sebelumnya kita sudah mempelajari context.WithCancel dimana kita mengirim sinyal cancel dari context secara manual. Selain itu kita juga bisa menambahkan sinyal cancel ke dalam context secara otomatis dengan menggunakan pengaturan waktu timeout. Dengan menggunakan pengaturan waktu, kita tidak perlu lagi melakukan pemanggilan eksekusi cancel secara manual, tetapi dengan timeout cancel akan otomatis dieksekusi jika waktu timeout sudah terlewati.

Kenapa kita harus menggunakan context?

Penggunaan context dengan timeout sangat cocok ketika kita melakukan query ke database atau http api, namun ingin menentukan batas maksimal timeout-nya. Saat membuat context dengan sinyal cancel otomatis menggunakan timeout, kita bisa menggunakan fungsi context.WithTimeout(parent,duration).

Manfaat dari penggunaan context.WithTimeout yaitu ketika kita akan melakukan proses eksekusi pada suatu fungsi, ketika fungsi tersebut melakukan eksekusi dengan kurun waktu tertentu yang melewati batas timeout proses maka, proses tersebut akan secara otomatis dilakukan cancel. Hal ini terjadi agar proses yang membutuhkan waktu lama tersebut tidak menjadi blocker terhadap proses-proses selanjutnya.

Implementasi dan sampel

Kita saat ini akan mencoba untuk mengimplementasikan context.WithTimeout. Method ini akan kita pakai sebagai pembatas melakukan akses kepada suatu fungsi berdasarkan batasan waktu tertentu. Lebih lanjutnya kita akan coba langsung pelajari kode program dibawah ini.

func main() {
	fmt.Println("Total Goroutine : ", runtime.NumGoroutine())

	parent := context.Background()
	ctx, cancel := context.WithTimeout(parent, 5*time.Second)
	defer cancel()

	destination := CreateCounterWithTimeout(ctx)
	fmt.Println("Total Goroutine : ", runtime.NumGoroutine())

	for n := range destination {
		fmt.Println("Counter : ", n)
	}

	fmt.Println("Total Goroutine : ", runtime.NumGoroutine())
}

func CreateCounterWithTimeout(ctx context.Context) chan int {
	destination := make(chan int)
	go func() {
		defer close(destination)
		counter := 1
		for {
			select {
			case <-ctx.Done():
				return
			default:
				destination <- counter
				counter++
				time.Sleep(1 * time.Second) // simulate slow process
			}
		}
	}()
	return destination
}

Pada program diatas sebenarnya memodifikasi fungsi sebelumnya yang sudah kita pelajari pada context.WithCancel. Yang membedakan dari artikel sebelumnya yaitu penggunaan context tentunya dan penggunaan defer cancel() yang mana pada artikel sebelumnya kita akan memanggil dan mengeksekusi fungsi cancel() dengan cara manual.

Berikut hasil dari program ketika sudah dijalankan dibawah ini.

✗ go run main.go
Total Goroutine :  1
Total Goroutine :  2
Counter :  1
Counter :  2
Counter :  3
Counter :  4
Counter :  5
Total Goroutine :  1

Terlihat hasil program terdapat total goroutine inisialisasi satu lalu saat mengeksekusi fungsi CreateCounterWithTiemout maka akan menambah goroutine menjadi dua dan fungsi langsung mencetak counter dengan waktu proses setiap counter yaitu satu detik. Lalu counter tersebut akan mengeluarkan 5 counter karena context yang dikirim ke fungsi goroutine tersebut hanya dibatasi waktu hanya 5 detik saja yang mana setiap proses membutuhkan satu detik maka proses fungsi tersebut akan mencetak hanya 5 counter saja. Lalu selanjutnya akan keluar dari proses dan otomatis context tersebut di batalkan karena sudah melebihi batas waktu dan goroutine-nya pun akan dihapus dan terbukti pada total goroutine setelahnya akan kembali menjadi satu gorutine.

Kesimpulan

context.WithTimeout ini method yang sangat bermanfaat sekali ketika kita memiliki fungsi proses yang tidak menentu proses tersebut akan selesai dalam batas waktu tertentu. Untuk menghindari kita terlalu lama menunggu hasil dari suatu api atau response dari proses tersebut maka, kita perlu membatasi suatu proses tersebut agar tidak menjadi blocker dengan satuan batas waktu timeout sehingga prosesnya akan selesai ataupun gagal akan tetap program kita memiliki proses yang tidak terlalu lama sesuai dengan toleransi yang sudah kita tentukan proses waktunya.