Dasar-dasar Goroutine

Termasuk bagian Pemrograman Berorientasi Objek dalam perjalanan GO di Coddy. Pelajaran 59 dari 107.

goroutine adalah thread eksekusi ringan yang dikelola oleh runtime Go. Tidak seperti thread tradisional yang menggunakan banyak memori, goroutine dimulai hanya dengan beberapa kilobyte ruang stack, sehingga kamu dapat menjalankan ribuan goroutine secara bersamaan.

Untuk memulai goroutine, cukup letakkan kata kunci go sebelum pemanggilan fungsi:

func sayHello(name string) {
    fmt.Println("Hello,", name)
}

func main() {
    go sayHello("Alice")  // berjalan secara bersamaan
    go sayHello("Bob")    // berjalan secara bersamaan
    
    time.Sleep(100 * time.Millisecond)
    fmt.Println("Done")
}

Saat go sayHello("Alice") dijalankan, program tidak menunggu sayHello selesai. Sebaliknya, program langsung melanjutkan ke baris berikutnya sementara sayHello berjalan di latar belakang. Karena itu, kita memerlukan time.Sleep. Tanpanya, main akan keluar sebelum goroutine selesai.

Kamu juga bisa menjalankan goroutine dengan fungsi anonim:

go func(msg string) {
    fmt.Println(msg)
}("Hello from goroutine")

Fungsi main sendiri berjalan dalam goroutine. Saat fungsi itu selesai, semua goroutine lainnya langsung dihentikan. Mereka tidak mendapat kesempatan untuk menyelesaikan tugasnya. Menggunakan time.Sleep adalah solusi sementara. Dalam pelajaran berikutnya, kamu akan mempelajari teknik sinkronisasi yang tepat dengan channel dan wait group.

Tantangan

Mudah

Mari kita buat task runner yang menjalankan beberapa task secara bersamaan menggunakan goroutine. Kamu akan membuat sistem sederhana tempat task berjalan di latar belakang sementara program utama terus berjalan, untuk menunjukkan cara goroutine memungkinkan eksekusi bersamaan.

Kamu akan mengatur kodemu dalam dua file:

tasks.go: Tentukan logika eksekusi task.
Buat struct Task dengan field Name (string) dan Duration (int, yang menyatakan milidetik).

Terapkan method Run() pada Task yang menyimulasikan pekerjaan dengan tidur selama durasi task, lalu mencetak: Task [Name] completed

Buat fungsi RunAllTasks(tasks []Task) yang menjalankan method Run() setiap task sebagai goroutine. Setelah menjalankan semua goroutine, fungsi tersebut harus tidur selama 500 milidetik agar goroutine selesai, lalu mencetak: All tasks launched
main.go: Baca informasi task dan atur eksekusi bersamaan.
Baca jumlah task, lalu baca nama dan durasi setiap task. Buat task dan berikan ke RunAllTasks. Setelah fungsi tersebut selesai, cetak: Main function done

Input berikut akan diberikan:

Baris 1: Jumlah task (integer)
Baris-baris berikutnya: Untuk setiap task, dua baris, yaitu nama task, lalu durasinya dalam milidetik

Contohnya, jika diberikan:

3
Download
100
Process
50
Upload
75

Output kamu harus menampilkan task yang selesai (urutannya dapat berbeda karena eksekusi bersamaan), diikuti pesan penyelesaian:

Task Process completed
Task Upload completed
Task Download completed
All tasks launched
Main function done

Catatan: Karena goroutine berjalan secara bersamaan, task dengan durasi lebih singkat biasanya selesai lebih dahulu. Urutan penyelesaian task bergantung pada durasinya, task yang lebih singkat selesai sebelum task yang lebih lama.

Gunakan time.Sleep dengan time.Duration dan time.Millisecond untuk jedanya. Ingat, tanpa jeda di RunAllTasks, fungsi tersebut akan selesai sebelum goroutine menuntaskan pekerjaannya.

Coba sendiri

package main

import (
	"fmt"
)

func main() {
	// Baca jumlah tugas
	var numTasks int
	fmt.Scanln(&numTasks)

	// TODO: Buat slice untuk menyimpan tugas
	
	// TODO: Baca nama dan durasi setiap tugas
	// Untuk setiap tugas:
	//   - Baca nama tugas
	//   - Baca durasi (sebagai bilangan bulat)
	//   - Buat Task dan tambahkan ke slice-mu

	// TODO: Panggil RunAllTasks dengan slice tugasmu

	// TODO: Cetak "Main function done"
}