Paglikha at pagsisimula ng mga bagong thread

"Kumusta, Amigo! Sinabi sa iyo ni Ellie ang tungkol sa mga thread, at sasabihin ko sa iyo kung paano ka nagtatrabaho sa kanila. Upang lumikha ng bagong thread, kailangan mong:"

1)  Lumikha ng isang bagay na Thread

2) Ipasa ito sa paraang gusto mong patakbuhin

3)  Tawagan ang paraan ng pagsisimula sa nilikhang bagay na Thread.

Isaalang-alang ang halimbawang ito:

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

Ang mga maliliit na programa sa Java ay karaniwang binubuo ng isang thread na tinatawag na «pangunahing thread». Ngunit ang mga programa ay mas madalas na naglulunsad ng mga karagdagang thread, na tinatawag na «mga thread ng bata». Ang pangunahing thread ay nagpapatakbo ng pangunahing pamamaraan at nagtatapos. Ang paraan ng pagtakbo ng Runnable ay ang kahalintulad na pamamaraan para sa mga thread ng bata.

"Ah, maraming mga thread ay nangangahulugang maraming pangunahing pamamaraan."

Upang sabihin sa isang bagay na Thread kung aling partikular na pamamaraan ang dapat nitong simulan, kailangan nating magpasa ng paraan dito. Sa Java, ginagawa ito gamit ang Runnable interface. Ang interface na ito ay naglalaman ng isang abstract na paraan: void run() . Ang Thread class ay may isang Thread(Runnable Runnable) constructor. Maaari kang pumasa sa anumang bagay na nagpapatupad ng Runnable na interface.

Dapat mamana ng iyong klase ang Runnable at i-override ang paraan ng pagpapatakbo nito . Ang paggamit sa paraang ito ay kung ano ang nagsisimula sa bagong thread. Maaari mong isulat ang anumang gusto mo sa run method.

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

Higit pa rito, maaari mong pagsamahin ang lahat ng ito sa isang klase. Ang Thread class ay nagmamana ng Runnable interface , kaya kailangan mo lang i-override ang run method nito :

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

}

"Ito ay isang mas eleganteng solusyon."

"Oo, ngunit mayroon itong mga pagkukulang:"

1)  Maaaring kailanganin mong magsimula ng ilang mga thread batay sa isang bagay, tulad ng sa halimbawa sa Natasha.

2)  Kung nagmana ka sa klase ng Thread, hindi ka makakapagdagdag ng isa pang klase ng magulang sa iyong klase.

3)  Kung may parent class ang iyong klase, hindi mo maaaring idagdag ang Thread bilang pangalawang parent class.

"Sa madaling salita, pagkatapos tawagin ang paraan ng pagsisimula, ang bawat isa sa mga thread ay magsisimulang magsagawa ng run method ng object na ipinasa sa constructor?"

"Oo. Kung walang ipapasa sa constructor, ipapatupad lang ng Thread ang internal run method nito."

"Ngunit bakit hindi na lang natin tawagan ang pamamaraan na ganito?"

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

"Kapag ang pangunahing thread ay umabot sa paraan ng pagtakbo , ang "maliit na robot" nito ay papasok lamang sa loob at ipapatupad ang lahat ng mga utos sa loob nito. Pagkatapos lamang na maisakatuparan ang mga ito ay babalik ito sa pangunahing pamamaraan at ipagpapatuloy ang pagpapatupad ng karagdagang mga utos. Kaya, walang segundo " maliit na robot" ay malilikha. Ang lahat ng gawain ay isasagawa nang sunud-sunod, hindi kahanay (sabay-sabay)."

"I see. Maaari ka bang tumawag ng ibang paraan, maliban sa pagtakbo?"

"Hindi. Ang lahat ng ito ay nakatali sa Runnable interface, na "alam" lamang tungkol sa isa sa mga pamamaraan nito: run() ."