Mencipta dan memulakan utas baharu

"Helo, Amigo! Ellie memberitahu anda tentang utas dan saya akan memberitahu anda cara anda bekerja dengan mereka. Untuk membuat utas baharu, anda perlu:"

1)  Buat objek Thread

2) Lulus kaedah yang anda ingin jalankan

3)  Panggil kaedah mula 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 daripada satu utas yang dipanggil «benang utama». Tetapi program lebih kerap melancarkan benang tambahan, yang dipanggil «benang kanak-kanak». Benang utama menjalankan kaedah utama dan berakhir. Kaedah larian Runnable ialah kaedah analog untuk benang kanak-kanak .

"Ah, banyak benang bermakna banyak kaedah utama."

Untuk memberitahu objek Thread kaedah khusus yang harus dimulakan, entah bagaimana kita perlu menyampaikan kaedah kepadanya. Di Java, ini dilakukan menggunakan antara muka Runnable . Antara muka ini mengandungi satu kaedah abstrak: void run() . Kelas Thread mempunyai pembina Thread(Runnable Runnable) . Anda boleh memasukkan mana-mana objek yang melaksanakan antara muka Runnable .

Kelas anda mesti mewarisi Runnable dan mengatasi kaedah lariannya . Menggunakan kaedah ini adalah perkara yang memulakan urutan baharu. Anda boleh menulis apa sahaja yang anda mahu dalam kaedah larian .

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();
}

Apatah lagi, anda boleh menggabungkan ini semua ke dalam satu kelas. Kelas Thread mewarisi antara muka Runnable , jadi anda hanya perlu mengatasi kaedah lariannya :

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 adalah penyelesaian yang lebih elegan."

"Ya, tetapi ia mempunyai kekurangannya:"

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

2)  Jika anda mewarisi daripada kelas Thread, anda tidak boleh menambah kelas induk lain pada kelas anda.

3)  Jika kelas anda mempunyai kelas induk, anda tidak boleh menambah Thread sebagai kelas induk kedua.

"Dengan kata lain, selepas kaedah mula dipanggil, setiap utas mula melaksanakan kaedah larian objek yang dihantar kepada pembina?"

"Ya. Jika tiada apa-apa dihantar kepada pembina, maka Thread hanya melaksanakan kaedah larian dalamannya."

"Tetapi mengapa kita tidak memanggil kaedah seperti ini?"

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

"Apabila utas utama mencapai kaedah larian , "robot kecil" nya hanya masuk ke dalam dan melaksanakan semua arahan di dalamnya. Hanya selepas ia dilaksanakan, ia akan kembali ke kaedah utama dan meneruskan laksanakan arahan selanjutnya. Oleh itu, tiada detik " robot kecil" akan dicipta. Semua kerja akan dilakukan secara berurutan, bukan selari (serentak)."

"Saya faham. Bolehkah anda memanggil kaedah lain, sesuatu selain daripada lari?"

"Tidak. Semuanya terikat dengan antara muka Runnable, yang hanya "tahu" tentang salah satu kaedahnya: run() ."