Memahami Concurrent dan Parallel Programming dengan Golang

Saat kita berbicara tentang programming, ada satu pertanyaan besar yang sering muncul: "Apakah lebih baik kita menggunakan concurrent programming atau parallel programming?" Kalau kita bayangkan dunia programming sebagai taman hiburan, concurrent programming itu seperti kita berbaris di banyak wahana secara bergantian (efisien, kan?), sedangkan parallel programming itu seperti kita punya banyak kembaran yang bisa menikmati semua wahana secara bersamaan.

Keduanya menarik, tapi bagaimana kita memilih yang tepat untuk situasi tertentu? Mari kita bahas ini secara mendalam dan menyenangkan.

Apa Itu Concurrent Programming?

Concurrent programming adalah seni menjalankan beberapa tugas secara bersamaan, bukan berarti semuanya berjalan pada saat yang sama, tetapi lebih seperti membagi perhatian kita ke banyak tugas. Bayangkan saat kita memasak: kita bisa memotong sayuran sambil merebus air. Tugasnya berganti-ganti, tapi kita tetap efisien. Dalam konteks programming, ini berarti satu prosesor beralih di antara beberapa tugas, memberikan ilusi bahwa semuanya berjalan secara bersamaan.

Contoh dalam Golang

Golang menyediakan dukungan luar biasa untuk concurrent programming melalui goroutines. Goroutines adalah cara kita mengatakan kepada komputer: "Hei, coba lakukan ini juga, ya, tapi santai aja."

package main

import (
	"fmt"
	"time"
)

func sayHello() {
	for i := 0; i < 5; i++ {
		fmt.Println("Hello!")
		time.Sleep(100 * time.Millisecond)
	}
}

func sayWorld() {
	for i := 0; i < 5; i++ {
		fmt.Println("World!")
		time.Sleep(150 * time.Millisecond)
	}
}

func main() {
	go sayHello()
	go sayWorld()
	time.Sleep(1 * time.Second)
	fmt.Println("Done!")
}

Penjelasan Kode

Pada kode di atas:

• Kita menggunakan kata kunci go untuk menjalankan fungsi sayHello dan sayWorld secara bersamaan.
• Meski terlihat seperti berjalan secara paralel, sebenarnya tugas ini hanya bergantian menggunakan prosesor yang sama.

Dan ya, kalau kamu lupa time.Sleep di main, program selesai sebelum kita sempat menikmati outputnya. Classic mistake, bro.

Apa Itu Parallel Programming?

Kalau concurrent itu seperti multitasking, parallel programming itu seperti memiliki banyak prosesor yang bekerja secara bersamaan untuk menyelesaikan tugas secara lebih cepat. Bayangkan kita punya empat teman yang masing-masing memotong sayuran, merebus air, mencuci piring, dan menyiapkan meja. Tugas selesai lebih cepat karena semua orang bekerja secara bersamaan.

Contoh dalam Golang

Untuk memanfaatkan parallel programming, kita perlu memastikan bahwa kita memiliki prosesor multi-core dan menggunakan GOMAXPROCS untuk mengatur jumlah prosesor yang digunakan.

package main

import (
	"fmt"
	"runtime"
	"sync"
)

func calculateSquare(wg *sync.WaitGroup, number int) {
	defer wg.Done()
	fmt.Printf("Square of %d is %d\n", number, number*number)
}

func main() {
	runtime.GOMAXPROCS(4) // Memanfaatkan 4 core
	var wg sync.WaitGroup

	numbers := []int{2, 4, 6, 8, 10}

	for _, number := numbers {
		wg.Add(1)
		go calculateSquare(&wg, number)
	}

	wg.Wait()
	fmt.Println("All tasks completed!")
}

Penjelasan Kode

• Dengan runtime.GOMAXPROCS(4), kita memberitahu Golang untuk menggunakan empat core CPU.
• Menggunakan sync.WaitGroup memastikan bahwa semua goroutine selesai sebelum program berakhir.

Kalau kita jalankan, tugas-tugas ini benar-benar dieksekusi secara paralel, berkat banyaknya core CPU yang bekerja.

Perbedaan Utama: Concurrent vs Parallel

Dalam memahami perbedaan antara concurrent dan parallel, kita bisa memulai dengan cara kerjanya. Concurrent programming fokus pada manajemen tugas yang berjalan secara bersamaan, sehingga tugas-tugas ini tampak dilakukan serentak meskipun sebenarnya bergantian menggunakan prosesor yang sama. Di sisi lain, parallel programming benar-benar menjalankan tugas-tugas tersebut secara simultan di prosesor yang berbeda, memberikan efisiensi yang lebih baik untuk pekerjaan yang berat secara komputasi.

Dari sisi kebutuhan perangkat keras, concurrent programming tidak memerlukan banyak core CPU. Bahkan, dengan satu core saja, kita sudah bisa menjalankan beberapa tugas secara bersamaan. Sebaliknya, parallel programming membutuhkan prosesor multi-core agar benar-benar bisa memanfaatkan keunggulannya dalam menjalankan tugas secara simultan.

Terakhir, dari aspek efisiensi, concurrent programming lebih efektif untuk tugas yang sering menunggu, seperti membaca file atau memproses data dari jaringan. Di sisi lain, parallel programming lebih cocok untuk pekerjaan yang bersifat berat secara komputasi, seperti komputasi matematis atau simulasi numerik yang kompleks.

Kenapa Golang Pilihan Tepat?

Golang dirancang dengan hati-hati untuk menangani masalah concurrent dan parallel programming. Dengan goroutines yang ringan dan channel untuk komunikasi antar-goroutine, kita bisa membangun sistem yang sangat efisien tanpa harus stres.

Channel: Komunikasi Tanpa Drama

Channel dalam Golang adalah seperti walkie-talkie untuk goroutine. Goroutine bisa saling mengirim pesan tanpa perlu khawatir soal konflik data.

package main

import "fmt"

func sum(numbers []int, ch chan int) {
	sum := 0
	for _, number := numbers {
		sum += number
	}
	ch <- sum // Kirim hasil ke channel
}

func main() {
	numbers := []int{1, 2, 3, 4, 5}
	ch := make(chan int)

	go sum(numbers[:len(numbers)/2], ch)
	go sum(numbers[len(numbers)/2:], ch)

	result1, result2 := <-ch, <-ch
	fmt.Println("Total Sum:", result1+result2)
}

Penjelasan Kode

• Dua goroutine menghitung sebagian dari array numbers.
• Hasilnya dikirim melalui channel ch dan digabungkan di main.

Kapan Harus Menggunakan Mana?

1. Concurrent Programming:

   • Ketika tugas kita lebih sering menunggu (seperti membaca file, menunggu respons API).
   • Contoh: Server HTTP yang menangani banyak permintaan secara bersamaan.

2. Parallel Programming:

   • Ketika tugas kita membutuhkan banyak komputasi matematis.
   • Contoh: Training model machine learning atau simulasi numerik.

Kesimpulan

Concurrent dan parallel programming adalah dua alat yang sangat berguna dalam kotak peralatan kita sebagai programmer. Dengan memahami kapan dan bagaimana menggunakannya, kita bisa menciptakan program yang lebih efisien dan responsif. Ingatlah, seperti halnya memilih antara kopi dan teh, keputusan tergantung pada kebutuhan dan situasi kita. Dan kalau ada yang bertanya, "Kenapa Golang?", jawablah dengan senyum, "Karena Golang itu seperti teman baik: ringan, bisa diandalkan, dan selalu ada untuk membantu kita."