కొత్త థ్రెడ్‌లను సృష్టించడం మరియు ప్రారంభించడం

"హలో, అమిగో! ఎల్లీ మీకు థ్రెడ్‌ల గురించి చెప్పారు మరియు మీరు వాటితో ఎలా పని చేస్తారో నేను మీకు చెప్పబోతున్నాను. కొత్త థ్రెడ్‌ని సృష్టించడానికి, మీరు వీటిని చేయాలి:"

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

చిన్న జావా ప్రోగ్రామ్‌లు సాధారణంగా "మెయిన్ థ్రెడ్" అని పిలువబడే ఒక థ్రెడ్‌ను కలిగి ఉంటాయి. కానీ ప్రోగ్రామ్‌లు తరచుగా అదనపు థ్రెడ్‌లను ప్రారంభిస్తాయి, వీటిని "చైల్డ్ థ్రెడ్‌లు" అని పిలుస్తారు. ప్రధాన థ్రెడ్ ప్రధాన పద్ధతిని నడుపుతుంది మరియు ముగుస్తుంది. చైల్డ్ థ్రెడ్‌ల కోసం రన్‌బుల్ యొక్క రన్ పద్ధతి సారూప్య పద్ధతి.

"ఆహ్, చాలా థ్రెడ్‌లు అంటే చాలా ప్రధాన పద్ధతులు."

థ్రెడ్ ఆబ్జెక్ట్ ఏ నిర్దిష్ట పద్ధతిని ప్రారంభించాలో చెప్పడానికి, మనం దానికి ఏదో ఒక పద్ధతిని పాస్ చేయాలి. జావాలో, ఇది రన్ చేయదగిన ఇంటర్‌ఫేస్‌ని ఉపయోగించి చేయబడుతుంది. ఈ ఇంటర్‌ఫేస్ ఒకే నైరూప్య పద్ధతిని కలిగి ఉంది: శూన్యమైన రన్() . థ్రెడ్ క్లాస్‌లో థ్రెడ్(రన్ చేయదగిన రన్ చేయదగిన) కన్స్ట్రక్టర్ ఉంది. రన్ చేయదగిన ఇంటర్‌ఫేస్‌ను అమలు చేసే ఏదైనా వస్తువులో మీరు పాస్ చేయవచ్చు .

మీ తరగతి తప్పనిసరిగా రన్ చేయదగినది మరియు దాని రన్ పద్ధతిని భర్తీ చేయాలి. ఈ పద్ధతిని ప్రారంభించడం వల్ల కొత్త థ్రెడ్ ప్రారంభమవుతుంది. రన్ మెథడ్‌లో మీకు కావలసినది రాయవచ్చు .

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