"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:

Code Paglalarawan 
class Printer implements Runnable
{
public void run()
{
System.out.println("I’m printer");
}
}
 Klase na nagpapatupad ng Runnable na interface. 
public static void main(String[] args)
{
Printer printer = new Printer();
Thread childThread = new Thread(printer);
childThread.start();
}
 1 Lumikha ng isang halimbawa ng klase ng Printer, na nagpapatupad ng run method.
2 Gumawa ng bagong Thread object. Ipinapasa namin sa constructor ang printer object, na ang run() na paraan ay kailangang i-invoke.
3 Simulan ang bagong thread sa pamamagitan ng pagtawag sa start() method.

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.

Java university

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

Paglikha at pagsisimula ng mga bagong thread - 1

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.

Code Paglalarawan 
class Printer implements Runnable
{
private String name;
public Printer(String name)
{
this.name = name;
}
public void run()
{
System.out.println("I’m " + this.name);
}
}
 Klase na nagpapatupad ng Runnable na interface. 
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();
}
 Lumikha ng dalawang thread, bawat isa ay ibabatay sa sarili nitong Printer object. 
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();
}
 Lumikha ng tatlong mga thread batay sa isang bagay na Printer.

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 :

Isa pang paraan para gumawa ng bagong thread 
class Printer extends Thread
{
private String name;
public Printer(String name)
{
this.name = name;
}
public void run()
{
System.out.println("I’m " + this.name);
}
}
 Magmana ng klase ng Thread , na nagpapatupad ng Runnable na interface, at pagkatapos ay i-override ang run method. 
public static void main(String[] args)
{
Printer printer = new Printer("Jack");
printer.start();

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

}
 Lumikha ng dalawang thread, bawat isa ay ibabatay sa sarili nitong Printer object.

"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?"

Code 
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() ."