Java - Pool Thread

Halo para pengembang Java masa depan! Hari ini, kita akan menyelam ke dunia yang menarik tentang Pool Thread. Jangan khawatir jika kamu masih baru di bidang pemrograman; saya akan memandu kamu melalui konsep ini langkah demi langkah, sama seperti yang saya lakukan untuk banyak mahasiswa selama tahun-tahun mengajar ini. Jadi, ambil secangkir kopi (atau teh, jika itu yang kamu suka), dan mari kita memulai!

Apa itu Pool Thread?

Bayangkan jika kamu menjalankan sebuah restoran yang sibuk. Setiap kali ada pelanggan baru yang datang, kamu bisa mempekerjakan penjual makanan baru untuk melayani mereka. tapi itu akan menjadi kacau dan mahal! Daripada itu, kamu memiliki jumlah penjual makanan yang tetap yang akan melayani banyak pelanggan. Itulah yang sebenarnya yang dilakukan oleh pool thread di pemrograman Java.

Pool thread adalah sekumpulan thread yang sudah diinisialisasi sebelumnya dan dapat digunakan untuk melakukan tugas. Daripada membuat thread baru untuk setiap tugas, yang bisa menjadi intensif sumber daya, kita menggunakan pool dari thread yang ada untuk menjalankan tugas ini.

Mengapa Menggunakan Pool Thread di Java?

Kamu mungkin bertanya-tanya, "Mengapa harus khawatir tentang pool thread? Tidak bisa kita hanya membuat thread baru saat kita memerlukannya?" Well, biarkan saya menjelaskan dengan sebuah cerita dari pengalaman mengajar saya.

Pada suatu waktu, saya memiliki seorang mahasiswa yang mencoba untuk membuat thread baru untuk setiap tugas di aplikasinya. Programnya berjalan baik untuk input kecil, tapi saat dia mencoba untuk memproses dataset yang besar, komputernya hampir kres! Itulah saat saya memperkenalkannya kepada pool thread.

Berikut adalah beberapa alasan utama untuk menggunakan pool thread:

1. Performa yang lebih baik: Membuat dan menghancurkan thread adalah mahal. Pool thread mengunakan ulang thread, menghemat overhead.
2. Manajemen sumber daya: Kamu bisa mengontrol jumlah maksimum thread yang dapat berjalan secara bersamaan.
3. Respon yang ditingkatkan: Tugas dapat dieksekusi segera oleh thread yang sudah berjalan.

Membuat Pool Thread di Java

Java menyediakan beberapa cara untuk membuat pool thread melalui kelas Executors. Mari kita lihat tiga metode umum:

1. Membuat Pool Thread Menggunakan Metode newFixedThreadPool()

Metode ini membuat pool thread dengan jumlah thread tetap. Mari kita lihat contohnya:

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class FixedThreadPoolExample {
public static void main(String[] args) {
ExecutorService executor = Executors.newFixedThreadPool(5);

for (int i = 0; i < 10; i++) {
Runnable worker = new WorkerThread("" + i);
executor.execute(worker);
}

executor.shutdown();
while (!executor.isTerminated()) {
}
System.out.println("Selesai semua thread");
}
}

class WorkerThread implements Runnable {
private String message;

public WorkerThread(String s) {
this.message = s;
}

public void run() {
System.out.println(Thread.currentThread().getName() + " (Start) pesan = " + message);
processMessage();
System.out.println(Thread.currentThread().getName() + " (End)");
}

private void processMessage() {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

Dalam contoh ini, kita membuat pool thread tetap dengan 5 thread. Kemudian kita menyerahkan 10 tugas ke pool ini. Pool akan menggunakan 5 thread itu untuk menjalankan 10 tugas ini, mengunakan ulang thread saat mereka tersedia.

2. Membuat Pool Thread Menggunakan Metode newCachedThreadPool()

Metode ini membuat pool thread yang akan membuat thread baru saat diperlukan, tetapi akan mengunakan ulang thread yang sebelumnya dibuat saat tersedia. Mari kita lihat bagaimana itu bekerja:

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CachedThreadPoolExample {
public static void main(String[] args) {
ExecutorService executor = Executors.newCachedThreadPool();

for (int i = 0; i < 100; i++) {
executor.execute(new Task());
}

executor.shutdown();
}
}

class Task implements Runnable {
public void run() {
System.out.println("Nama Thread: " + Thread.currentThread().getName());
}
}

Dalam contoh ini, kita membuat pool thread yang tercache dan menyerahkan 100 tugas kepadanya. Pool akan membuat thread baru saat diperlukan dan mengunakan ulang mereka saat mungkin.

3. Membuat Pool Thread Menggunakan Metode newScheduledThreadPool()

Metode ini membuat pool thread yang dapat menjadwalkan perintah untuk menjalankan setelah jeda yang ditentukan, atau untuk menjalankan secara periodik. Ini adalah contohnya:

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ScheduledThreadPoolExample {
public static void main(String[] args) {
ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);

Runnable task = () -> System.out.println("Menjalankan tugas pada " + System.nanoTime());

executor.scheduleAtFixedRate(task, 0, 2, TimeUnit.SECONDS);
}
}

Dalam contoh ini, kita membuat pool thread yang dijadwalkan dengan satu thread. Kemudian kita menjadwalkan tugas untuk menjalankan setiap 2 detik.

Metode di ExecutorService

Berikut adalah tabel dari metode penting di antaraface ExecutorService:

Metode	Deskripsi
execute(Runnable)	Menjalankan perintah yang diberikan pada saat tertentu di masa depan
submit(Callable)	Menyerahkan tugas yang mengembalikan nilai untuk dieksekusi dan mengembalikan Future
shutdown()	Memulai penutupan yang beraturan di mana tugas yang sudah dikirim akan dieksekusi, tetapi tidak ada tugas baru yang akan diterima
shutdownNow()	Mencoba untuk menghentikan semua tugas yang sedang dieksekusi dan menghentikan pemrosesan tugas yang menunggu
isShutdown()	Mengembalikan true jika executor ini sudah ditutup
isTerminated()	Mengembalikan true jika semua tugas telah selesai setelah penutupan

Kesimpulan

Dan itu adalah semua, teman-teman! Kita telah melakukan perjalanan melalui negeri Java Pool Thread, dari memahami mengapa mereka berguna hingga membuat dan menggunakan mereka dalam berbagai cara. Ingat, seperti dalam analogi restoran kita, pool thread membantu kita mengelola sumber daya secara efisien.

Selama tahun-tahun mengajar ini, saya telah melihat mahasiswa yang bergejolak dari konsep threading dasar menjadi membangun aplikasi multi-threaded yang kompleks dan efisien. Dengan latihan dan kesabaran, kamu juga akan sampai ke sana!

Sebagai kamu melanjutkan perjalanan Java-mu, terus eksplor dan eksperimen. Pool thread adalah hanya satu alat di toolkit yang luas yang Java menyediakan untuk pemrograman konkuрren. Happy coding, dan semoga thread-mu selalu dijadikan pool secara efisien!

Credits: Image by storyset