Java - Pengawalan Thread

Hai sana, para ahli Java masa depan! Hari ini, kita akan melantikan pengembaraan menarik ke dalam dunia Pengawalan Thread Java. Jangan bimbang jika anda baru dalam bidang programming - saya akan memandu anda dalam perjalanan ini langkah demi langkah, seperti yang telah saya lakukan untuk banyak murid selama tahun-tahun pengajaran saya. Jadi, pegangkan kayu sihir anda (papan kekunci), dan mari kita buat sedikit sihir coding!

apa itu Thread?

Sebelum kita melompat ke pengawalan thread, mari kita memahami apa itu thread. Bayangkan anda berada di dapur, memasak makanan yang rumit. Anda adalah program utama, dan setiap tugas yang anda lakukan (memotong sayur, mengaduk saus, memeriksa Oven) adalah seperti thread. Semua ini adalah bagian dari proses keseluruhan yang sama (membuat makan malam), tetapi mereka adalah tugas yang terpisah dan dapat berjalan bersamaan.

Dalam Java, thread adalah subproses yang ringan, unit proses terkecil. Itu adalah cara untuk membuat path eksekusi terpisah untuk tugas tertentu dalam program anda.

Mengapa Pengawalan Thread?

Sekarang, mengapa kita ingin mengawal thread ini? Mari kita teruskan dengan analogi memasak. Kadang-kadang, anda perlu menghentikan pengadukan saus untuk memeriksa daging panggang. Atau anda mungkin perlu menunggu air mendidih sebelum menambah pasta. Demikian pula, dalam programming, kita seringkali perlu mengawal aliran dan waktu thread yang berbeda untuk memastikan program kita berjalan mulus dan efisien.

Metode untuk Mengawal Thread Java

Java menyediakan beberapa metode untuk mengawal thread. Mari kita lihat mereka dalam tabel yang praktis:

Metode	Deskripsi
start()	Memulai thread, menyebabkan metode run() dipanggil
run()	Mengandung kode yang membentuk tugas thread
sleep()	Menyebabkan thread berhenti untuk waktu yang ditentukan
join()	Menunggu thread untuk berhenti
yield()	Menyebabkan thread berhenti secara singkat dan membolehkan thread lain berjalan
interrupt()	Mengganggu thread, menyebabkan ia berhenti apa yang sedang dilakukan
isAlive()	Memeriksa apakah thread masih berjalan

Sekarang, mari kita masuk kedalam setiap metode ini dengan beberapa contoh!

1. start() dan run()

Dua metode ini bekerja bersama. Ini adalah contoh sederhana:

public class MyThread extends Thread {
public void run() {
System.out.println("Thread saya sedang berjalan!");
}

public static void main(String args[]) {
MyThread thread = new MyThread();
thread.start();
}
}

Dalam contoh ini, kita membuat thread baru dan memanggil metode start()nya. Ini, pada gilirannya, memanggil metode run(), yang mengandung kode yang akan dijalankan oleh thread.

2. sleep()

Metode sleep() seperti menekan tombol "snooze" pada alarm Anda. Itu membuat thread berhenti eksekusi untuk waktu yang ditentukan. Berikut cara kerjanya:

public class SleepyThread extends Thread {
public void run() {
for (int i = 1; i <= 5; i++) {
System.out.println("Thread sedang menghitung: " + i);
try {
Thread.sleep(1000); // Berhenti untuk 1 detik
} catch (InterruptedException e) {
System.out.println("Thread terganggu!");
}
}
}

public static void main(String args[]) {
SleepyThread thread = new SleepyThread();
thread.start();
}
}

Thread ini akan menghitung dari 1 hingga 5, berhenti untuk 1 detik antara setiap hitungan. Seperti orang tidur yang perlahan menghitung domba!

3. join()

Metode join() seperti menunggu teman Anda menyelesaikan tugasnya sebelum Anda kedua pergi makan siang. Itu membuat thread saat ini menunggu hingga thread yang dijoin selesai eksekusi. Berikut contohnya:

public class JoinExample {
public static void main(String[] args) {
Thread t1 = new Thread(() -> {
for (int i = 0; i < 5; i++) {
System.out.println("Thread 1: " + i);
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});

Thread t2 = new Thread(() -> {
try {
t1.join(); // Menunggu t1 selesai
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Thread 2: Saya selesai menunggu!");
});

t1.start();
t2.start();
}
}

Dalam contoh ini, Thread 2 menunggu Thread 1 selesai sebelum mencetak pesannya.

4. yield()

Metode yield() seperti being sopan dalam percakapan - itu menyarankan thread untuk berhenti untuk membolehkan thread lain berjalan yang memiliki prioritas yang sama. Namun, itu hanya petunjuk ke scheduler dan dapat diabaikan. Berikut contoh sederhana:

public class YieldExample implements Runnable {
public void run() {
for (int i = 0; i < 3; i++) {
System.out.println(Thread.currentThread().getName() + " dalam kendali");
Thread.yield();
}
}

public static void main(String[] args) {
Thread t1 = new Thread(new YieldExample(), "Thread 1");
Thread t2 = new Thread(new YieldExample(), "Thread 2");
t1.start();
t2.start();
}
}

Anda mungkin melihat thread bergantian kendali, tetapi ingat, itu tidak dijamin!

5. interrupt()

Metode interrupt() seperti mengentaskan seseorang di bahu untuk mendapat perhatian. Itu tidak menghentikan thread segera, tetapi menyetel flag yang thread dapat memeriksa. Berikut cara kerjanya:

public class InterruptExample implements Runnable {
public void run() {
try {
while (!Thread.currentThread().isInterrupted()) {
System.out.println("Thread sedang berjalan...");
Thread.sleep(1000);
}
} catch (InterruptedException e) {
System.out.println("Thread terganggu saat tidur");
}
System.out.println("Thread telah selesai.");
}

public static void main(String[] args) throws InterruptedException {
Thread thread = new Thread(new InterruptExample());
thread.start();
Thread.sleep(5000); // Biarkan thread berjalan selama 5 detik
thread.interrupt();
}
}

Dalam contoh ini, thread berjalan hingga ia terganggu setelah 5 detik.

6. isAlive()

Metode isAlive() seperti memeriksa apakah seseorang masih di meja kerjanya. Itu mengembalikan true jika thread masih berjalan. Berikut contoh cepat:

public class AliveExample extends Thread {
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println("Thread berjalan: " + i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

public static void main(String[] args) throws InterruptedException {
AliveExample thread = new AliveExample();
thread.start();

while (thread.isAlive()) {
System.out.println("Thread utama akan menunggu sampai MyThread masih hidup");
Thread.sleep(1500);
}
System.out.println("Thread utama selesai");
}
}

Contoh ini menunjukkan thread utama menunggu dan memeriksa apakah thread khusus masih hidup.

Penutup

Dan di sana, teman-teman! Kita telah melakukan perjalanan melalui negeri Pengawalan Thread Java, menelusuri setiap metode seperti petualang di dunia baru. Ingat, seperti memasak, menguasai pengawalan thread memerlukan latihan. Jangan khawatir untuk mencoba metode ini dalam kode Anda sendiri.

Saat kita menutup pelajaran ini, saya teringat sebuah murid yang pernah katakan kepadaku bahwa pengertian thread akhirnya "beresonansi" untuk dia ketika dia mengimaginasikan mereka sebagai koki berbeda di dapur, semua bekerja bersama untuk membuat makanan. Jadi, temukan analogi yang bekerja untuk Anda!

Terus coding, terus belajar, dan terutama, bersenang-senang! Siapa tahu, aplikasi multithreaded besar berikutnya mungkin saja datang dari salah satu dari Anda. Sampaijumpa nanti, semoga thread Anda berjalan mulus dan kode Anda bebas bug!

Credits: Image by storyset