Concurrency - Goroutines

Pada sesi ini akan di bahas bagaimana menggunakan Goroutines

Goroutine adalam mini thread yang ringan yang ada pada Go. Goroutine merupakan salah satu bagian paling penting dalam concurrent programming di Go, salah satunya adalah eksekusi-nya dijalankan di multi core processor. Kita bisa tentukan berapa banyak core yang aktif, makin banyak akan semakin cepat.

Untuk menerapkan goroutine, proses yang akan dieksekusi sebagai goroutine harus dibungkus kedalam sebuah fungsi. Pada saat pemanggilan fungsi tersebut, ditambahkan keyword go didepannya, dengan itu goroutine baru akan dibuat dengan tugas adalah menjalankan proses yang ada dalam fungsi tersebut.

package main

import (
	"fmt"
)

func f(n int) {
	for i := 0; i < 10; i++ {
		fmt.Println(n, ":", i)
	}
}

func main() {
	go f(0)
	fmt.Println("Hello Concurrency")
}

Misalnya kita membuat sebuah fungsi f dengan parameter n bertipe int . Fungsi ini sangat sederhana yaitu menampilkan angka 0 sampai 9 secara berurutan. Jika kode di atas dijalankan maka akan menampilkan output berikut:

Menampilkan hasil penggunaan goroutines

Pada output di atas kita mencoba untuk menjalankan program 2 kali. Hasilnya berbeda-beda. Lalu kenapa output dari iterasi 0-9 tidak ditampilkan?

Pada goroutine, program tidak akan menunggu return statement dari function namun langsung menjalankan statement line berikutnya.

Pada kasus di atas func main selesai lebih dulu daripada function f (masih menjalankan proses concurrency) jadi program dianggap berhenti dan exit.

Untuk menunggu concurrency selesai dijalankan kita bisa mengatur dengan menambahkan time delay pada function main .

package main

import (
	"fmt"
	"time"
)

func f(n int) {
	for i := 0; i < 10; i++ {
		fmt.Println(n, ":", i)
	}
}

func main() {
	go f(0)
	// Time delay agar menunggu proses concurrency selesai
	time.Sleep(100 * time.Millisecond)
	fmt.Println("Hello Concurrency")
}

Menampilkan hasil dari goroutine

Studi Kasus

Kita akan mempraktikan studi kasus yang sama dengan contoh pada materi concurrency yaitu proses bongkar barang dari truck ke gudang.

package main

import (
	"fmt"
)

func main() {
	for i := 0; i < 10; i++ {
		go loadItemOntoCart()
		go moveItemIntoWarehouse()
		go unloadItemIntoStorage()
		go returnEmptyCart()
	}

	var input string
	fmt.Scanln(&input)
}

// load items onto cart
// move items into warehouse building
// unload items into storage
// return empty cart

func loadItemOntoCart() {
	fmt.Println("load items onto cart")
}

func moveItemIntoWarehouse() {
	fmt.Println("move items into warehouse building")
}

func unloadItemIntoStorage() {
	fmt.Println("unload items into storage")
}

func returnEmptyCart() {
	fmt.Println("return empty cart")
}

Function berjalan secara concurrency (independen)

Kita lihat ada penggunaan fmt.Scanln yaitu untuk memblock statement selanjutnya agar program tidak exit secara otomatis. Ini dikarenakan func main kemungkinan akan selesai terlebih dahulu dibandingkan proses perulangan yang berisi proses goroutine.