Java - Pool Thread

Halo semua, pengembang Java masa depan! Hari ini, kita akan menyelam ke atas dunia yang menarik tentang Pool Thread. Jangan khawatir jika anda baru mengenali pengaturcaraan; Saya akan membimbing anda melalui konsep ini langkah demi langkah, sama seperti yang saya lakukan untuk pelbagai pelajar selama tahun tahun mengajar saya. Jadi, rakitkan satu rakus kopi (atau teh, jika itu adalah pilihan anda), dan mari kita mula!

Apa itu Pool Thread?

Bayangkan anda menjalankan sebuah restoran yang sibuk. Setiap kali pelanggan baru datang, anda boleh mengambil seorang pelayan baru untuk melayaninya. Tetapi itu akan menjadi kacau dan mahal! Sebaliknya, anda memiliki jumlah pelayan tetap yang akan melayani pelanggan banyak. Itu hampir sama dengan apa yang pool thread lakukan dalam pengaturcaraan Java.

Pool thread adalah sekumpulan thread yang telah diwujudkan sebelumnya dan boleh digunakan untuk melakukan tugas. Daripada membuat thread baru untuk setiap tugas, yang boleh menjadi penyebab penGGunaan sumber yang berlebihan, kita menggunakan pool thread yang ada untuk menjalankan tugas ini.

Mengapa Gunakan Pool Thread di Java?

Anda mungkin bertanya-tanya, "Mengapa perlu dengan pool thread? Tak bolehkah kita hanya membuat thread baru apabila kita memerlukannya?" Well, biarkan saya jelaskan dengan sebuah cerita kecil dari pengalaman mengajar saya.

Sebuah masa, saya ada seorang pelajar yang mencuba untuk membuat thread baru untuk setiap tugas dalam aplikasinya. Programnya berjalan baik untuk input kecil, tetapi apabila dia mencuba untuk memproses dataset yang besar, komputer dia hampir kena karam! Itu adalah apabila saya memperkenalkannya kepada pool thread.

Berikut adalah beberapa alasan utama untuk menggunakan pool thread:

1. Prestasi yang lebih baik: Membuat dan menghancurkan thread adalah mahal. Pool thread menggunaan thread semula, menghemat overhead.
2. Pengurusan sumber: Anda boleh mengawal jumlah maksimum thread yang boleh dijalankan secara serentak.
3. Responsivitas yang diperbaiki: Tugas boleh dijalankan 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 cara umum:

1. Membuat Pool Thread Menggunakan metod newFixedThreadPool()

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

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() + " (Mula) message = " + message);
processMessage();
System.out.println(Thread.currentThread().getName() + " (Akhir)");
}

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

Dalam contoh ini, kita membuat pool thread tetap dengan 5 thread. Kita kemudian mengirim 10 tugas ke pool ini. Pool akan menggunakan 5 thread untuk menjalankan 10 tugas ini, menggunaan thread semula apabila tersedia.

2. Membuat Pool Thread Menggunakan metod newCachedThreadPool()

Metode ini membuat pool thread yang akan membuat thread baru apabila diperlukan, tetapi akan menggunaan thread yang telah diwujudkan sebelumnya apabila tersedia. Mari kita lihat bagaimana ia 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 di-cache dan mengirim 100 tugas kepadanya. Pool akan membuat thread baru apabila diperlukan dan menggunaan mereka apabila mungkin.

3. Membuat Pool Thread Menggunakan metod newScheduledThreadPool()

Metode ini membuat pool thread yang dapat menjadwalkan perintah untuk dijalankan setelah delay yang diberikan, atau untuk dijalankan secara periodik. Ini adalah contoh:

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("Mengeksekusi tugas pada " + System.nanoTime());

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

Dalam contoh ini, kita membuat pool thread yang dijadwalkan dengan satu thread. Kita kemudian menjadwalkan tugas untuk dijalankan setiap 2 saat.

Metod di ExecutorService

Berikut adalah tabel yang menjelaskan metod penting di atas antara muka ExecutorService:

Metod	Keterangan
execute(Runnable)	Eksekusi perintah yang diberikan pada masa depan
submit(Callable)	Mengirimkan tugas yang mengembalikan nilai untuk eksekusi dan mengembalikan Future
shutdown()	Memulakan penutupan yang beraturan di mana tugas yang dikirim sebelumnya akan dijalankan, tetapi tidak ada tugas baru yang akan diterima
shutdownNow()	Mencuba untuk menghentikan semua tugas yang sedang dijalankan dan menghentikan pemrosesan tugas yang menunggu
isShutdown()	Mengembalikan nilai benar jika executor ini telah ditutup
isTerminated()	Mengembalikan nilai benar jika semua tugas telah selesai setelah ditutup

Kesimpulan

Dan itu adalah, rakan-rakan! Kita telah melakukan perjalanan melalui wilayah Java Pool Thread, dari memahami mengapa mereka berguna ke membuat dan menggunakannya dalam pelbagai cara. Ingat, seperti analogi restoran kita, pool thread membantu kita mengurus sumber dengan efisiensi.

Selama tahun tahun mengajar saya, saya telah melihat pelajar yang bergegas dari kesulitan dengan konsep threading dasar ke pembangunan aplikasi multi-threaded yang kompleks dan efisien. Dengan latihan dan kesabaran, anda juga akan mencapai tujuannya!

Sebagai anda teruskan perjalanan Java anda, terus untuk menjelajahi dan menguji. Pool thread hanya satu alat di atas rakit yang besar yang Java menyediakan untuk pengaturcaraan konkuren. Happy coding, dan semoga thread anda sentiasa dijadikan dengan efisiensi!

Credits: Image by storyset