Membuat dan memulai utas baru

"Halo, Amigo! Ellie memberi tahu Anda tentang utas, dan saya akan memberi tahu Anda cara Anda bekerja dengannya. Untuk membuat utas baru, Anda perlu:"

1)  Buat objek Utas

2) Berikan metode yang ingin Anda jalankan

3)  Panggil metode start pada objek Thread yang dibuat.

Pertimbangkan contoh ini:

class Printer implements Runnable
{
public void run()
{
System.out.println("I’m printer");
}
}

public static void main(String[] args)
{
Printer printer = new Printer();
Thread childThread = new Thread(printer);
childThread.start();
}

Program Java kecil biasanya terdiri dari satu utas yang disebut «utas utama». Tetapi program lebih sering meluncurkan utas tambahan, yang disebut «utas anak». Utas utama menjalankan metode utama dan berakhir. Metode run dari Runnable adalah metode analog untuk utas anak.

"Ah, banyak utas berarti banyak metode utama."

Untuk memberi tahu objek Thread metode spesifik mana yang harus dimulai, kita perlu meneruskan metode ke objek tersebut. Di Java, ini dilakukan dengan menggunakan antarmuka Runnable . Antarmuka ini berisi metode abstrak tunggal: void run() . Kelas Thread memiliki konstruktor Thread(Runnable Runnable) . Anda dapat meneruskan objek apa pun yang mengimplementasikan antarmuka Runnable .

Kelas Anda harus mewarisi Runnable dan mengganti metode run -nya . Memanggil metode ini adalah yang memulai utas baru. Anda dapat menulis apa pun yang Anda inginkan dalam metode run .

class Printer implements Runnable
{
private String name;
public Printer(String name)
{
this.name = name;
}
public void run()
{
System.out.println("I’m " + this.name);
}
}

public static void main(String[] args)
{
Printer printer1 = new Printer("Nick");
Thread thread1 = new Thread(printer1);
thread1.start();

Printer printer2 = new Printer("Jack");
Thread thread2 = new Thread(printer2);
thread2.start();
}

public static void main(String[] args)
{
Printer printer = new Printer("Natasha");

Thread thread1 = new Thread(printer);
thread1.start();

Thread thread2 = new Thread(printer);
thread2.start();

Thread thread3 = new Thread(printer);
thread3.start();
}

Terlebih lagi, Anda dapat menggabungkan semua ini menjadi satu kelas. Kelas Thread mewarisi Runnable interface , jadi Anda hanya perlu mengganti metode run -nya :

class Printer extends Thread
{
private String name;
public Printer(String name)
{
this.name = name;
}
public void run()
{
System.out.println("I’m " + this.name);
}
}

public static void main(String[] args)
{
Printer printer = new Printer("Jack");
printer.start();

Printer printer2 = new Printer("Jack");
printer2.start();

}

"Ini solusi yang lebih elegan."

"Ya, tapi ada kekurangannya:"

1)  Anda mungkin perlu memulai beberapa utas berdasarkan satu objek, seperti pada contoh dengan Natasha.

2)  Jika Anda mewarisi dari kelas Thread, Anda tidak dapat menambahkan kelas induk lain ke kelas Anda.

3)  Jika kelas Anda memiliki kelas induk, Anda tidak dapat menambahkan Thread sebagai kelas induk kedua.

"Dengan kata lain, setelah metode start dipanggil, masing-masing utas mulai menjalankan metode run dari objek yang diteruskan ke konstruktor?"

"Ya. Jika tidak ada yang diteruskan ke konstruktor, maka Thread akan menjalankan metode run internalnya."

"Tapi kenapa kita tidak memanggil metode seperti ini saja?"

public static void main(String[] args)
{
 Printer printer1 = new Printer("Nick");
 printer1.run();
}

"Ketika utas utama mencapai metode jalankan , "robot kecilnya" hanya masuk ke dalam dan mengeksekusi semua perintah di dalamnya. Hanya setelah dieksekusi, ia akan kembali ke metode utama dan melanjutkan eksekusi perintah lebih lanjut. Jadi, tidak ada detik " robot kecil" akan dibuat. Semua pekerjaan akan dilakukan secara berurutan, tidak secara paralel (bersamaan)."

"Begitu. Bisakah kamu memanggil metode lain, sesuatu selain lari?"

"Tidak. Itu semua terkait dengan antarmuka Runnable, yang hanya "tahu" tentang salah satu metodenya: run() ."