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

"ఇక్కడ కొత్త మరియు ఆసక్తికరమైన అంశం ఉంది."

"మీరు వేర్వేరు మోడ్‌లలో థ్రెడ్‌లను ప్రారంభించవచ్చని తేలింది."

"ప్రధాన థ్రెడ్ దాని పనిని పూర్తి చేసినప్పుడు ఒక ప్రామాణిక ప్రోగ్రామ్ (ఒకే థ్రెడ్‌తో) రన్ అవడం ఆగిపోతుంది. ప్రధాన థ్రెడ్ అమలును పూర్తి చేస్తుంది, ప్రోగ్రామ్ ముగుస్తుంది మరియు JVM దాని మెమరీని ఖాళీ చేస్తుంది."

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

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

"ప్రోగ్రామ్ నడుస్తున్నప్పుడు ఈ సర్వీస్ థ్రెడ్‌లు అవసరమవుతాయి, కానీ అవి వాటి స్వంతంగా అవసరం లేదు."

"అవును, నాకు అర్థమైంది."

"జావా ఒక థ్రెడ్‌ను డెమోన్‌గా అమలు చేయడానికి మిమ్మల్ని అనుమతిస్తుంది. అలాంటి థ్రెడ్‌లు ఇతరుల మాదిరిగానే పనిచేస్తాయి, అయితే ప్రోగ్రామ్‌లోని అన్ని నాన్-డెమోన్ థ్రెడ్‌లు రద్దు చేయబడి మరియు డెమోన్ థ్రెడ్‌లు మాత్రమే మిగిలి ఉంటే, JVM ప్రోగ్రామ్‌ను మూసివేస్తుంది."

"కాబట్టి 'సర్వీస్' థ్రెడ్‌ని ప్రకటించడం అంటే ప్రోగ్రామ్‌ని ముగించినప్పుడు అది పరిగణించబడదని అర్థం. అంతేనా?"

"ఉహ్హ్... సరే, మీరు ఖచ్చితంగా షార్ట్ అండ్ స్వీట్ గా చెప్పారు. ముఖ్యంగా, నేను మీకు చెప్పాలనుకున్నది అదే."

"క్లుప్తత ఒక ప్రతిభ. మరియు ప్రతిభావంతులైన రోబోలు ప్రతిదానిలో ప్రతిభావంతులు."

"ఏవైనా ప్రశ్నలు వున్నాయ?"

"మీరు డెమోన్‌గా థ్రెడ్‌ను ఎలా ప్రారంభిస్తారు? కొన్ని డెమన్‌థ్రెడ్ క్లాస్ నుండి వారసత్వంగా పొందారా?"

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

Thread thread = new LoggerThread();
thread.setDaemon(true);
thread.start();

"మరి అంతేనా?"

"అవును."

"థ్రెడ్‌ను సృష్టించే మరియు ప్రారంభించే ప్రక్రియపై నేను మీ దృష్టిని మరోసారి ఆకర్షించాలనుకుంటున్నాను."

"థ్రెడ్ ఆబ్జెక్ట్‌ను సృష్టించడం వల్ల థ్రెడ్ సృష్టించబడదు. థ్రెడ్ ఆబ్జెక్ట్ థ్రెడ్ కాదు. స్టార్ట్() పద్ధతిని పిలిచినప్పుడు JVM ఒక థ్రెడ్‌ను సృష్టిస్తుంది. థ్రెడ్ అనేది థ్రెడ్ గురించి సమాచారాన్ని యాక్సెస్ చేయడానికి మరియు ఇచ్చే ప్రత్యేక JVM ఆబ్జెక్ట్. మీరు కొంచెం కంట్రోల్ చేసుకోండి."

"నేను చూస్తున్నాను. ధన్యవాదాలు, ఎల్లీ."