புதிய இழைகளை உருவாக்குதல் மற்றும் தொடங்குதல்

"ஹலோ, அமிகோ! எல்லி உங்களிடம் நூல்களைப் பற்றிச் சொன்னார், நீங்கள் அவர்களுடன் எவ்வாறு வேலை செய்கிறீர்கள் என்பதை நான் உங்களுக்குச் சொல்லப் போகிறேன். புதிய நூலை உருவாக்க, நீங்கள் செய்ய வேண்டியது:"

1)  ஒரு நூல் பொருளை உருவாக்கவும்

2) நீங்கள் இயக்க விரும்பும் முறையை அனுப்பவும்

3)  உருவாக்கப்பட்ட த்ரெட் பொருளின் தொடக்க முறையை அழைக்கவும்.

இந்த உதாரணத்தைக் கவனியுங்கள்:

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

சிறிய ஜாவா நிரல்கள் பொதுவாக "முக்கிய நூல்" என்று அழைக்கப்படும் ஒரு நூலைக் கொண்டிருக்கும். ஆனால் நிரல்கள் பெரும்பாலும் கூடுதல் நூல்களைத் தொடங்குகின்றன, அவை "குழந்தை நூல்கள்" என்று அழைக்கப்படுகின்றன. முக்கிய நூல் முக்கிய முறையை இயக்குகிறது மற்றும் முடிவடைகிறது. Runnable இன் ரன் முறையானது குழந்தை நூல்களுக்கான ஒத்த முறை ஆகும்.

"ஆஹா, நிறைய நூல்கள் என்றால் நிறைய முக்கிய முறைகள் என்று அர்த்தம்."

ஒரு த்ரெட் ஆப்ஜெக்ட் எந்த குறிப்பிட்ட முறையைத் தொடங்க வேண்டும் என்று சொல்ல, அதற்கு எப்படியாவது ஒரு முறையை அனுப்ப வேண்டும். ஜாவாவில், இது இயங்கக்கூடிய இடைமுகத்தைப் பயன்படுத்தி செய்யப்படுகிறது. இந்த இடைமுகத்தில் ஒரு சுருக்க முறை உள்ளது: void 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();
}

மேலும் என்னவென்றால், இவை அனைத்தையும் ஒரே வகுப்பில் இணைக்கலாம். த்ரெட் கிளாஸ் இயக்கக்கூடிய இடைமுகத்தைப் பெறுகிறது , எனவே நீங்கள் அதன் இயக்க முறையை மட்டும் மீற வேண்டும் :

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

}

"இது மிகவும் நேர்த்தியான தீர்வு."

"ஆம், ஆனால் அதன் குறைபாடுகள் உள்ளன:"

1)  நடாஷாவின் எடுத்துக்காட்டில் உள்ளதைப் போல, ஒரு பொருளின் அடிப்படையில் நீங்கள் பல நூல்களைத் தொடங்க வேண்டியிருக்கலாம்.

2)  நீங்கள் த்ரெட் வகுப்பிலிருந்து மரபுரிமை பெற்றால், உங்கள் வகுப்பில் மற்றொரு பெற்றோர் வகுப்பைச் சேர்க்க முடியாது.

3)  உங்கள் வகுப்பில் பெற்றோர் வகுப்பு இருந்தால், நீங்கள் இரண்டாவது பெற்றோர் வகுப்பாக த்ரெட்டைச் சேர்க்க முடியாது.

"வேறு வார்த்தைகளில் கூறுவதானால், தொடக்க முறை என்று அழைக்கப்பட்ட பிறகு, ஒவ்வொரு திரிகளும் கட்டமைப்பாளருக்கு அனுப்பப்பட்ட பொருளின் ரன் முறையை செயல்படுத்தத் தொடங்குகின்றனவா?"

"ஆம். கன்ஸ்ட்ரக்டருக்கு எதுவும் அனுப்பப்படவில்லை என்றால், த்ரெட் அதன் உள் இயக்க முறையை மட்டும் செயல்படுத்துகிறது."

"ஆனால் நாம் ஏன் இந்த முறையை அழைக்கக்கூடாது?"

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

"மெயின் த்ரெட் ரன் முறையை அடையும் போது, ​​அதன் "சிறிய ரோபோ" உள்ளே சென்று அதன் உள்ளே உள்ள அனைத்து கட்டளைகளையும் செயல்படுத்துகிறது. அவை செயல்படுத்தப்பட்ட பின்னரே அது பிரதான முறைக்குத் திரும்பி, மேலும் கட்டளைகளை இயக்கும். எனவே, இரண்டாவது இல்லை " சிறிய ரோபோ" உருவாக்கப்படும். அனைத்து வேலைகளும் இணையாக அல்ல (ஒரே நேரத்தில்) தொடர்ச்சியாக செய்யப்படும்."

"நான் பார்க்கிறேன். நீங்கள் வேறு ஏதாவது முறை அழைக்க முடியுமா, ரன் தவிர வேறு ஏதாவது?"

"இல்லை. இது இயங்கக்கூடிய இடைமுகத்துடன் இணைக்கப்பட்டுள்ளது, இது அதன் முறைகளில் ஒன்றைப் பற்றி மட்டுமே "தெரியும்": run() ."