కలిసి ఉత్తమం: జావా మరియు థ్రెడ్ క్లాస్. పార్ట్ I - అమలు యొక్క థ్రెడ్స్

పరిచయం

మల్టీథ్రెడింగ్ మొదటి నుండి జావాలో నిర్మించబడింది. కాబట్టి, మల్టీథ్రెడింగ్ అని పిలువబడే ఈ విషయాన్ని క్లుప్తంగా చూద్దాం. మేము ఒరాకిల్ నుండి అధికారిక పాఠాన్ని రిఫరెన్స్ పాయింట్‌గా తీసుకుంటాము: " పాఠం: "హలో వరల్డ్!" అప్లికేషన్ ". మేము మా హలో వరల్డ్ ప్రోగ్రామ్ కోడ్‌ని ఈ క్రింది విధంగా కొద్దిగా మారుస్తాము:

class HelloWorldApp {
    public static void main(String[] args) {
        System.out.println("Hello, " + args[0]);
    }
}

argsప్రోగ్రామ్ ప్రారంభించబడినప్పుడు ఆమోదించబడిన ఇన్‌పుట్ పారామితుల శ్రేణి. తరగతి పేరుకు సరిపోలే మరియు పొడిగింపు ఉన్న పేరుతో ఈ కోడ్‌ని ఫైల్‌కి సేవ్ చేయండి .java. జావాక్ యుటిలిటీని ఉపయోగించి దీన్ని కంపైల్ చేయండి : javac HelloWorldApp.java. అప్పుడు, మేము మా కోడ్‌ను కొన్ని పరామితితో అమలు చేస్తాము, ఉదాహరణకు, "రోజర్": java HelloWorldApp Roger మా కోడ్ ప్రస్తుతం తీవ్రమైన లోపాన్ని కలిగి ఉంది. మీరు ఏ ఆర్గ్యుమెంట్‌ను పాస్ చేయకుంటే (అంటే కేవలం "java HelloWorldApp"ని అమలు చేయండి), అప్పుడు మేము ఎర్రర్‌ని పొందుతాము:

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 0
        at HelloWorldApp.main(HelloWorldApp.java:3)

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

జావా మరియు థ్రెడ్లు

థ్రెడ్ అంటే ఏమిటో అర్థం చేసుకోవడానికి, మీరు జావా ప్రోగ్రామ్ ఎలా ప్రారంభమవుతుందో అర్థం చేసుకోవాలి. మన కోడ్‌ని ఈ క్రింది విధంగా మారుద్దాం:

class HelloWorldApp {
    public static void main(String[] args) {
		while (true) {
			// Do nothing
		}
	}
}

ఇప్పుడు దానిని మళ్ళీ తో కంపైల్ చేద్దాం javac. సౌలభ్యం కోసం, మేము మా జావా కోడ్‌ను ప్రత్యేక విండోలో అమలు చేస్తాము. Windowsలో, ఇది ఇలా చేయవచ్చు: start java HelloWorldApp. ఇప్పుడు మనం jps యుటిలిటీని ఉపయోగిస్తాము, జావా మనకు ఏ సమాచారాన్ని చెప్పగలదో చూడడానికి: మొదటి సంఖ్య PID లేదా ప్రాసెస్ ID. ప్రక్రియ అంటే ఏమిటి?

A process is a combination of code and data sharing a common virtual address space.

ప్రక్రియలతో, వివిధ ప్రోగ్రామ్‌లు అవి అమలులో ఉన్నప్పుడు ఒకదానికొకటి వేరుచేయబడతాయి: ప్రతి అప్లికేషన్ ఇతర ప్రోగ్రామ్‌లతో జోక్యం చేసుకోకుండా మెమరీలో దాని స్వంత ప్రాంతాన్ని ఉపయోగిస్తుంది. మరింత తెలుసుకోవడానికి, నేను ఈ ట్యుటోరియల్ చదవమని సిఫార్సు చేస్తున్నాను: ప్రక్రియలు మరియు థ్రెడ్లు . ఒక ప్రక్రియ థ్రెడ్ లేకుండా ఉనికిలో ఉండదు, కాబట్టి ఒక ప్రక్రియ ఉంటే, అది కనీసం ఒక థ్రెడ్‌ని కలిగి ఉంటుంది. అయితే ఇది జావాలో ఎలా వస్తుంది? మేము జావా ప్రోగ్రామ్‌ను ప్రారంభించినప్పుడు, అమలు పద్ధతితో ప్రారంభమవుతుంది main. మేము ప్రోగ్రామ్‌లోకి అడుగుపెడుతున్నాము, కాబట్టి ఈ ప్రత్యేక mainపద్ధతిని ఎంట్రీ పాయింట్ అంటారు. mainజావా వర్చువల్ మెషీన్ (JVM) మా ప్రోగ్రామ్‌ను అమలు చేయడం ప్రారంభించగలిగేలా పద్ధతి ఎల్లప్పుడూ "పబ్లిక్ స్టాటిక్ శూన్యం"గా ఉండాలి . మరింత సమాచారం కోసం, జావా ప్రధాన పద్ధతి ఎందుకు స్థిరంగా ఉంది?. జావా లాంచర్ (java.exe లేదా javaw.exe) ఒక సాధారణ C అప్లికేషన్ అని తేలింది: ఇది నిజానికి JVMని కలిగి ఉన్న వివిధ DLLలను లోడ్ చేస్తుంది. జావా లాంచర్ నిర్దిష్ట జావా నేటివ్ ఇంటర్‌ఫేస్ (JNI) కాల్‌లను చేస్తుంది. JNI అనేది జావా వర్చువల్ మెషీన్ ప్రపంచాన్ని C++ ప్రపంచంతో అనుసంధానించడానికి ఒక మెకానిజం. కాబట్టి, లాంచర్ JVM కాదు, దానిని లోడ్ చేయడానికి ఒక మెకానిజం. JVMని ప్రారంభించడానికి ఇది సరైన ఆదేశాలను అమలు చేయడానికి తెలుసు. అవసరమైన వాతావరణాన్ని సెటప్ చేయడానికి JNI కాల్‌లను ఎలా ఉపయోగించాలో దీనికి తెలుసు. ఈ వాతావరణాన్ని సెటప్ చేయడంలో ప్రధాన థ్రెడ్‌ను సృష్టించడం ఉంటుంది, దీనిని "ప్రధాన" అని పిలుస్తారు. జావా ప్రక్రియలో ఏ థ్రెడ్‌లు ఉన్నాయో బాగా వివరించడానికి, మేము jvisualvm ని ఉపయోగిస్తాముసాధనం, ఇది JDKతో చేర్చబడింది. ప్రాసెస్ యొక్క పిడ్ తెలుసుకోవడం, మేము వెంటనే ఆ ప్రక్రియ గురించి సమాచారాన్ని చూడవచ్చు: jvisualvm --openpid <process id> ఆసక్తికరంగా, ప్రతి థ్రెడ్ ప్రాసెస్‌కు కేటాయించిన మెమరీలో దాని స్వంత ప్రత్యేక ప్రాంతాన్ని కలిగి ఉంటుంది. ఈ మెమరీ నిర్మాణాన్ని స్టాక్ అంటారు. ఒక స్టాక్ ఫ్రేమ్‌లను కలిగి ఉంటుంది. ఫ్రేమ్ ఒక పద్ధతి యొక్క క్రియాశీలతను సూచిస్తుంది (ఒక అసంపూర్తి పద్ధతి కాల్). ఒక ఫ్రేమ్‌ను StackTraceElementగా కూడా సూచించవచ్చు ( StackTraceElement కోసం Java APIని చూడండి ). మీరు ఇక్కడ చర్చలో ప్రతి థ్రెడ్‌కు కేటాయించిన మెమరీ గురించి మరింత సమాచారాన్ని కనుగొనవచ్చు: " జావా (JVM) ప్రతి థ్రెడ్‌కు స్టాక్‌ను ఎలా కేటాయిస్తుంది ". మీరు జావా APIని చూసి , "థ్రెడ్" అనే పదం కోసం శోధిస్తే, మీరు java.lang.Thread ని కనుగొంటారు.తరగతి. ఇది జావాలో థ్రెడ్‌ని సూచించే తరగతి, మరియు మేము దానితో పని చేయాల్సి ఉంటుంది.

జావా.లాంగ్.థ్రెడ్

జావాలో, థ్రెడ్ java.lang.Threadక్లాస్ యొక్క ఉదాహరణ ద్వారా సూచించబడుతుంది. థ్రెడ్ క్లాస్ యొక్క సందర్భాలు ఎగ్జిక్యూషన్ థ్రెడ్‌లు కాదని మీరు వెంటనే అర్థం చేసుకోవాలి. JVM మరియు ఆపరేటింగ్ సిస్టమ్ ద్వారా నిర్వహించబడే తక్కువ-స్థాయి థ్రెడ్‌ల కోసం ఇది కేవలం ఒక రకమైన API. మేము జావా లాంచర్‌ని ఉపయోగించి JVMని ప్రారంభించినప్పుడు, అది main"మెయిన్" అనే థ్రెడ్‌ను మరియు కొన్ని ఇతర హౌస్‌కీపింగ్ థ్రెడ్‌లను సృష్టిస్తుంది. థ్రెడ్ క్లాస్ కోసం JavaDocలో పేర్కొన్న విధంగా: When a Java Virtual Machine starts up, there is usually a single non-daemon thread. 2 రకాల థ్రెడ్‌లు ఉన్నాయి: డెమోన్‌లు మరియు నాన్-డెమన్‌లు. డెమోన్ థ్రెడ్‌లు బ్యాక్‌గ్రౌండ్ (హౌస్ కీపింగ్) థ్రెడ్‌లు, ఇవి బ్యాక్‌గ్రౌండ్‌లో కొంత పని చేస్తాయి. "డెమన్" అనే పదం మాక్స్‌వెల్ యొక్క దెయ్యాన్ని సూచిస్తుంది. మీరు ఈ వికీపీడియా కథనంలో మరింత తెలుసుకోవచ్చు . డాక్యుమెంటేషన్‌లో పేర్కొన్నట్లుగా, JVM ప్రోగ్రామ్ (ప్రాసెస్)ని అమలు చేయడాన్ని కొనసాగిస్తుంది:

• Runtime.exit () పద్ధతిని అంటారు
• అన్ని నాన్-డెమన్ థ్రెడ్‌లు వాటి పనిని పూర్తి చేస్తాయి (లోపాలు లేకుండా లేదా విసిరిన మినహాయింపులతో)

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

public static void main(String[] args) {
	Thread currentThread = Thread.currentThread();
	ThreadGroup threadGroup = currentThread.getThreadGroup();
	System.out.println("Thread: " + currentThread.getName());
	System.out.println("Thread Group: " + threadGroup.getName());
	System.out.println("Parent Group: " + threadGroup.getParent().getName());
}

సమూహాలు థ్రెడ్ నిర్వహణకు క్రమాన్ని అందిస్తాయి. సమూహాలతో పాటు, థ్రెడ్‌లు వాటి స్వంత మినహాయింపు హ్యాండ్లర్‌ను కలిగి ఉంటాయి. ఒక ఉదాహరణను పరిశీలించండి:

public static void main(String[] args) {
	Thread th = Thread.currentThread();
	th.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
		@Override
		public void uncaughtException(Thread t, Throwable e) {
			System.out.println("An error occurred: " + e.getMessage());
		}
	});
    System.out.println(2/0);
}

సున్నా ద్వారా విభజించడం వలన హ్యాండ్లర్ క్యాచ్ చేసే లోపం ఏర్పడుతుంది. మీరు మీ స్వంత హ్యాండ్లర్‌ను పేర్కొనకుంటే, JVM డిఫాల్ట్ హ్యాండ్లర్‌ను అమలు చేస్తుంది, ఇది మినహాయింపు యొక్క స్టాక్ ట్రేస్‌ను StdErrorకి అవుట్‌పుట్ చేస్తుంది. ప్రతి థ్రెడ్‌కు కూడా ప్రాధాన్యత ఉంటుంది. మీరు ఈ కథనంలో ప్రాధాన్యతల గురించి మరింత చదవవచ్చు: మల్టీథ్రెడింగ్‌లో జావా థ్రెడ్ ప్రాధాన్యత .

థ్రెడ్‌ను సృష్టిస్తోంది

డాక్యుమెంటేషన్‌లో పేర్కొన్నట్లుగా, థ్రెడ్‌ను రూపొందించడానికి మాకు 2 మార్గాలు ఉన్నాయి. మొదటి మార్గం మీ స్వంత సబ్‌క్లాస్‌ను సృష్టించడం. ఉదాహరణకి:

public class HelloWorld{
    public static class MyThread extends Thread {
        @Override
        public void run() {
            System.out.println("Hello, World!");
        }
    }

    public static void main(String[] args) {
        Thread thread = new MyThread();
        thread.start();
    }
}

మీరు చూడగలిగినట్లుగా, పని యొక్క పని పద్ధతిలో జరుగుతుంది run(), కానీ థ్రెడ్ కూడా పద్ధతిలో ప్రారంభించబడింది start(). ఈ పద్ధతులను గందరగోళానికి గురి చేయవద్దు: మేము నేరుగా r un()పద్ధతిని కాల్ చేస్తే, కొత్త థ్రెడ్ ప్రారంభించబడదు. start()కొత్త థ్రెడ్‌ని సృష్టించమని JVMని అడిగే పద్ధతి ఇది . మేము థ్రెడ్‌ని వారసత్వంగా పొందే ఈ ఎంపిక ఇప్పటికే చెడ్డది, ఎందుకంటే మేము థ్రెడ్‌ని మా తరగతి సోపానక్రమంలో చేర్చాము. రెండవ లోపం ఏమిటంటే, మేము "ఒకే బాధ్యత" సూత్రాన్ని ఉల్లంఘించడం ప్రారంభించాము. అంటే, థ్రెడ్‌ను నియంత్రించడానికి మరియు ఈ థ్రెడ్‌లో కొన్ని పనిని నిర్వహించడానికి మా తరగతి ఏకకాలంలో బాధ్యత వహిస్తుంది. సరైన మార్గం ఏమిటి? run()మేము భర్తీ చేసే అదే పద్ధతిలో సమాధానం కనుగొనబడింది :

public void run() {
	if (target != null) {
		target.run();
	}
}

థ్రెడ్ క్లాస్ యొక్క ఉదాహరణను సృష్టించేటప్పుడు మనం పాస్ చేయగల targetకొన్ని ఇక్కడ ఉన్నాయి. java.lang.Runnableదీని అర్థం మనం దీన్ని చేయగలము:

public class HelloWorld{
    public static void main(String[] args) {
        Runnable task = new Runnable() {
            public void run() {
                System.out.println("Hello, World!");
            }
        };
        Thread thread = new Thread(task);
        thread.start();
    }
}

Runnableజావా 1.8 నుండి కూడా ఫంక్షనల్ ఇంటర్‌ఫేస్‌గా ఉంది. ఇది థ్రెడ్ టాస్క్ కోసం మరింత అందమైన కోడ్‌ని వ్రాయడం సాధ్యం చేస్తుంది:

public static void main(String[] args) {
	Runnable task = () -> {
		System.out.println("Hello, World!");
	};
	Thread thread = new Thread(task);
	thread.start();
}

ముగింపు

ఈ చర్చ థ్రెడ్ అంటే ఏమిటి, థ్రెడ్‌లు ఎలా ఉనికిలోకి వస్తాయి మరియు థ్రెడ్‌లతో ఏ ప్రాథమిక కార్యకలాపాలను నిర్వహించవచ్చో స్పష్టం చేస్తుందని నేను ఆశిస్తున్నాను. తర్వాతి భాగంలో , థ్రెడ్‌లు ఒకదానితో ఒకటి ఎలా సంకర్షణ చెందుతాయో అర్థం చేసుకోవడానికి మరియు థ్రెడ్ జీవిత చక్రాన్ని అన్వేషించడానికి మేము ప్రయత్నిస్తాము. కలిసి ఉత్తమం: జావా మరియు థ్రెడ్ క్లాస్. పార్ట్ II — సమకాలీకరణ ఉత్తమం: జావా మరియు థ్రెడ్ క్లాస్. పార్ట్ III — కలిసి మెరుగ్గా పరస్పర చర్య: జావా మరియు థ్రెడ్ క్లాస్. పార్ట్ IV — కాల్ చేయదగినది, భవిష్యత్తు మరియు స్నేహితులు కలిసి ఉండటం మంచిది: జావా మరియు థ్రెడ్ క్లాస్. పార్ట్ V - ఎగ్జిక్యూటర్, థ్రెడ్‌పూల్, ఫోర్క్/జాయిన్ బెటర్ టుగెదర్: జావా మరియు థ్రెడ్ క్లాస్. పార్ట్ VI — ఫైర్ అవే!