జావా ఆర్కిటెక్చర్ సంకలనం మరియు వ్యాఖ్యాన ప్రక్రియను మిళితం చేస్తుంది. ఇది సూత్రీకరించేటప్పుడు పాల్గొన్న వివిధ ప్రక్రియలను వివరిస్తుంది . నేను టాపిక్‌తో ప్రారంభించే ముందు ఈ ఆర్టికల్ యొక్క ఎజెండాతో మిమ్మల్ని పరిచయం చేద్దాం.
sql లో సబ్‌స్ట్రింగ్ ఎలా ఉపయోగించాలి
పేర్కొన్న పాయింటర్ల క్రింద మా చర్చా అంశాలు ఉంటాయి:
జావా ఆర్కిటెక్చర్ అంటే ఏమిటో అర్థం చేసుకోవడం ద్వారా ప్రారంభిద్దాం?
జావా ఆర్కిటెక్చర్ అంటే ఏమిటి?
ఇక్కడ, నేను మీకు జావా నిర్మాణాన్ని సాధారణ దశల్లో వివరిస్తాను.
- జావాలో, సంకలనం మరియు వివరణ యొక్క ప్రక్రియ ఉంది.
- లో వ్రాసిన కోడ్ , జావా కంపైలర్ చేత చేయబడిన బైట్ కోడ్‌లుగా మార్చబడుతుంది.
- బైట్ సంకేతాలు, తరువాత JVM చేత యంత్ర కోడ్‌గా మార్చబడతాయి.
- మెషిన్ కోడ్ నేరుగా యంత్రం ద్వారా అమలు చేయబడుతుంది.
ఈ రేఖాచిత్రం జావా కోడ్ యొక్క అంతర్గత పనిని వివరిస్తుంది, లేదా ఖచ్చితంగా, జావా ఆర్కిటెక్చర్!
ఇప్పుడు, జావా ఆర్కిటెక్చర్లో కొంచెం లోతుగా త్రవ్వి, వివిధ విషయాల గురించి మాట్లాడుదాం .
జావా ఆర్కిటెక్చర్ యొక్క భాగాలు
జావా భాషలో మూడు ప్రధాన భాగాలు ఉన్నాయి: JVM, JRE, మరియు JDK .
జావా వర్చువల్ మెషిన్, జావా రన్‌టైమ్ ఎన్విరాన్మెంట్ మరియు జావా డెవలప్‌మెంట్ కిట్ వరుసగా.
నేను ప్రతి ఒక్కటి ఒక్కొక్కటిగా వివరించాను:
జావా వర్చువల్ మెషిన్:
WORA గురించి ఎప్పుడైనా విన్నారా? (ఒకసారి ఎక్కడైనా రన్ చేయండి). ఏ ప్లాట్‌ఫామ్‌లోనైనా కోడ్‌ను అమలు చేయగల సామర్థ్యం ఉన్నందున జావా అనువర్తనాలను WORA అని పిలుస్తారు. ఇది జెవిఎం వల్ల మాత్రమే జరుగుతుంది. JVM అనేది జావా ప్లాట్‌ఫాం భాగం, ఇది జావా ప్రోగ్రామ్‌లను అమలు చేయడానికి వాతావరణాన్ని అందిస్తుంది. JVM బైట్‌కోడ్‌ను మెషిన్ కోడ్‌లోకి వివరిస్తుంది, ఇది జావా ప్రోగ్రామ్ నడుస్తున్న యంత్రంలో అమలు అవుతుంది.
కాబట్టి, క్లుప్తంగా, JVM ఈ క్రింది విధులను నిర్వహిస్తుంది:
- కోడ్‌ను లోడ్ చేస్తుంది
- కోడ్‌ను ధృవీకరిస్తుంది
- కోడ్‌ను అమలు చేస్తుంది
- రన్‌టైమ్ వాతావరణాన్ని అందిస్తుంది
ఇప్పుడు, నేను మీకు JVM నిర్మాణాన్ని చూపిస్తాను. ఇక్కడ ఉంది!
వివరణ:
క్లాస్ లోడర్ : క్లాస్ లోడర్ JVM యొక్క ఉపవ్యవస్థ. తరగతి ఫైళ్ళను లోడ్ చేయడానికి ఇది ఉపయోగించబడుతుంది. మేము జావా ప్రోగ్రామ్ను అమలు చేసినప్పుడల్లా, క్లాస్ లోడర్ దాన్ని మొదట లోడ్ చేస్తుంది.
తరగతి పద్ధతి ప్రాంతం : ఇది JVM లోని డేటా ఏరియాలో ఒకటి, దీనిలో క్లాస్ డేటా నిల్వ చేయబడుతుంది. స్టాటిక్ వేరియబుల్స్, స్టాటిక్ బ్లాక్స్, స్టాటిక్ మెథడ్స్, ఇన్‌స్టాన్స్ మెథడ్స్ ఈ ప్రాంతంలో నిల్వ చేయబడతాయి.
కుప్ప : JVM ప్రారంభమైనప్పుడు ఒక కుప్ప సృష్టించబడుతుంది. అప్లికేషన్ నడుస్తున్నప్పుడు ఇది పరిమాణం పెరుగుతుంది లేదా తగ్గుతుంది.
స్టాక్ : జెవిఎం స్టాక్‌ను థ్రెడ్ స్టాక్ అంటారు. ఇది JVM మెమరీలోని డేటా ప్రాంతం, ఇది ఒకే అమలు థ్రెడ్ కోసం సృష్టించబడుతుంది. థ్రెడ్ యొక్క JVM స్టాక్ వివిధ అంశాలను నిల్వ చేయడానికి థ్రెడ్ ద్వారా ఉపయోగించబడుతుంది, అనగా స్థానిక వేరియబుల్స్, పాక్షిక ఫలితాలు మరియు కాలింగ్ పద్ధతి మరియు రాబడి కోసం డేటా.
స్థానిక స్టాక్ : ఇది మీ అనువర్తనంలో ఉపయోగించిన అన్ని స్థానిక పద్ధతులను ఉపసంహరించుకుంటుంది.
ఎగ్జిక్యూషన్ ఇంజిన్:
- జిట్ కంపైలర్
- వ్యర్థాలు సేకరించువాడు
JIT కంపైలర్: ది జస్ట్-ఇన్-టైమ్ (JIT) కంపైలర్ రన్‌టైమ్ వాతావరణంలో ఒక భాగం. రన్ టైమ్‌లో మెషిన్ కోడ్‌కు బైట్‌కోడ్‌లను కంపైల్ చేయడం ద్వారా జావా అనువర్తనాల పనితీరును మెరుగుపరచడంలో ఇది సహాయపడుతుంది. JIT కంపైలర్ అప్రమేయంగా ప్రారంభించబడుతుంది. ఒక పద్ధతి సంకలనం చేయబడినప్పుడు, JVM ఆ పద్ధతి యొక్క సంకలనం కోడ్‌ను నేరుగా పిలుస్తుంది. JIT కంపైలర్ ఆ పద్ధతి యొక్క బైట్‌కోడ్‌ను మెషిన్ కోడ్‌లోకి కంపైల్ చేస్తుంది, దీన్ని అమలు చేయడానికి “సమయానికి” కంపైల్ చేస్తుంది.
వ్యర్థాలు సేకరించువాడు: పేరు వివరించినట్లు వ్యర్థాలు సేకరించువాడు ఉపయోగించని పదార్థాన్ని సేకరించడం. బాగా, JVM లో ఈ పని చెత్త సేకరణ ద్వారా జరుగుతుంది. ఇది JVM కుప్ప స్థలంలో లభించే ప్రతి వస్తువును ట్రాక్ చేస్తుంది మరియు అవాంఛిత వాటిని తొలగిస్తుంది.
చెత్త సేకరించేవారు మార్క్ మరియు స్వీప్ అని పిలువబడే రెండు సాధారణ దశల్లో పనిచేస్తారు:
- గుర్తు - చెత్త సేకరించేవారు ఏ మెమరీ భాగాన్ని వాడుకలో ఉన్నారో మరియు ఏవి కాదని గుర్తిస్తారు
- స్వీప్ - ఇది “మార్క్” దశలో గుర్తించిన వస్తువులను తొలగిస్తుంది.
జావా రన్‌టైమ్ పర్యావరణం:
JRE సాఫ్ట్‌వేర్ రన్‌టైమ్ వాతావరణాన్ని నిర్మిస్తుంది, దీనిలో జావా ప్రోగ్రామ్‌లను అమలు చేయవచ్చు. JRE అనేది ఆన్-డిస్క్ సిస్టమ్, ఇది మీ జావా కోడ్‌ను తీసుకుంటుంది, అవసరమైన లైబ్రరీలతో మిళితం చేస్తుంది మరియు దానిని అమలు చేయడానికి JVM ను ప్రారంభిస్తుంది. JRE మీ జావా ప్రోగ్రామ్‌లను అమలు చేయడానికి అవసరమైన లైబ్రరీలను మరియు సాఫ్ట్‌వేర్‌లను కలిగి ఉంది. JRE అనేది JDK లో ఒక భాగం (ఇది మేము తరువాత అధ్యయనం చేస్తాము) కాని విడిగా డౌన్‌లోడ్ చేసుకోవచ్చు.
జావా డెవలప్‌మెంట్ కిట్:
జావా డెవలప్‌మెంట్ కిట్ (జెడికె) అనేది జావా అనువర్తనాలు మరియు ఆప్లెట్‌లను అభివృద్ధి చేయడానికి ఉపయోగించే సాఫ్ట్‌వేర్ అభివృద్ధి వాతావరణం. ఇది JRE మరియు అనేక అభివృద్ధి సాధనాలను కలిగి ఉంది, ఒక వ్యాఖ్యాత / లోడర్ (జావా), కంపైలర్ (జావాక్), ఒక ఆర్కైవర్ (కూజా), మరొక సాధనంతో పాటు డాక్యుమెంటేషన్ జనరేటర్ (జావాడోక్).
సూచన ద్వారా కాల్ చేయండి c ++
రేఖాచిత్రంలో చూపిన నీలం ప్రాంతం JDK. ఇప్పుడు, మీ అందరికీ అభివృద్ధి సాధనాలను వివరించాను.
జావా : ఇది అన్ని జావా అనువర్తనాలకు లాంచర్.
జావాక్ : జావా ప్రోగ్రామింగ్ భాషల కంప్లైయర్.
జావాడోక్ : ఇది API డాక్యుమెంటేషన్ జనరేటర్.
కూజా : అన్ని JAR ఫైళ్ళను సృష్టిస్తుంది మరియు నిర్వహించండి.
జావా నిర్మాణంతో ముందుకు సాగడం, జావా ప్లాట్‌ఫాం ఎలా స్వతంత్రంగా ఉందో అర్థం చేసుకుందాం?
జావా ప్లాట్‌ఫాం ఎలా స్వతంత్రంగా ఉంటుంది?
ఏదైనా ప్రోగ్రామింగ్ భాషను ప్లాట్‌ఫాం-స్వతంత్రంగా ఎప్పుడు పిలుస్తారు? సరే, దాని అభివృద్ధి మరియు సంకలనానికి సంబంధించి అందుబాటులో ఉన్న అన్ని ఆపరేటింగ్ సిస్టమ్‌లలో అమలు చేయగలిగితే.
ఇప్పుడు, జావా బైట్‌కోడ్ కారణంగా ప్లాట్‌ఫాం-స్వతంత్రంగా ఉంటుంది. బైట్‌కోడ్ అంటే ఏమిటో నేను మీకు చెప్తాను? సరళంగా చెప్పాలంటే,
బైట్‌కోడ్ అనేది JVM యొక్క కోడ్, ఇది యంత్రానికి అర్థమయ్యేది.
జావాలో బైట్‌కోడ్ అమలు ఇది వేదిక-స్వతంత్ర భాష అని రుజువు చేస్తుంది.
ఇక్కడ, జావా బైట్‌కోడ్ అమలు ప్రక్రియలో ఉన్న దశలను నేను మీకు చూపిస్తాను.
పాల్గొన్న దశల వివరణ క్రింద ఉంది:
sample.java javac (నమూనా. తరగతి) → JVM (sample.obj) → తుది ఉత్పత్తి
జావాలో ప్రోగ్రామ్ను ఎలా ఆపాలి
మొదటి సోర్స్ కోడ్ జావా కంపైలర్ చేత ఉపయోగించబడుతుంది మరియు .class ఫైల్‌లో మార్చబడుతుంది. క్లాస్ ఫైల్ కోడ్ బైట్ కోడ్ రూపంలో ఉంది మరియు ఆ క్లాస్ ఫైల్ JVM చేత ఆబ్జెక్ట్ ఫైల్‌గా మార్చడానికి ఉపయోగించబడుతుంది. ఆ తరువాత, మీరు మీ స్క్రీన్‌లో తుది అవుట్‌పుట్‌ను చూడవచ్చు.
జావా ఆర్కిటెక్చర్ వ్యాసంలో ముందుకు సాగడం, యొక్క భావనను అర్థం చేసుకుందాం జావాలో JIT .
జావాలో JIT
సాధారణంగా JIT అని పిలువబడే జస్ట్ ఇన్ టైమ్ కంపైలర్, రన్ టైమ్‌లో జావా ఆధారిత అనువర్తనాల పనితీరు ఆప్టిమైజేషన్‌కు ప్రాథమికంగా బాధ్యత వహిస్తుంది. అప్లికేషన్ యొక్క పనితీరు కంపైలర్ మీద ఆధారపడి ఉంటుంది.
అంతర్గత ప్రక్రియను మీకు చూపించే సాధారణ రేఖాచిత్రం ఇక్కడ ఉంది.
JIT కంపైలర్ పద్ధతి యొక్క బైట్ కోడ్‌ను మెషిన్ కోడ్‌లోకి కంపైల్ చేస్తుంది, దీన్ని అమలు చేయడానికి “జస్ట్ ఇన్ టైమ్” కంపైల్ చేస్తుంది. ఒక పద్ధతి సంకలనం చేయబడినప్పుడు, JVM ఆ పద్ధతి యొక్క సంకలనం కోడ్‌ను నేరుగా పిలుస్తుంది.
లోతుగా డైవ్ చేద్దాం:
అందించిన ఇన్స్ట్రక్షన్ సెట్‌ను బట్టి బైట్ కోడ్‌ను సరైన యంత్ర సూచనలకు అర్థం చేసుకోవాలి లేదా కంపైల్ చేయాలి. అలాగే, ఇన్స్ట్రక్షన్ ఆర్కిటెక్చర్ బైట్ కోడ్ ఆధారితంగా ఉంటే వీటిని నేరుగా అమలు చేయవచ్చు. బైట్ కోడ్‌ను వివరించడం అమలు వేగాన్ని ప్రభావితం చేస్తుంది.
పనితీరును మెరుగుపరచడానికి, JIT కంపైలర్లు రన్ సమయంలో జావా వర్చువల్ మెషిన్ (JVM) తో సంకర్షణ చెందుతాయి మరియు తగిన బైట్‌కోడ్ సీక్వెన్స్‌లను స్థానిక మెషిన్ కోడ్‌లోకి కంపైల్ చేస్తాయి (రేఖాచిత్రంలో చూపిన విధంగా). JIT కంపైలర్‌ను ఉపయోగిస్తున్నప్పుడు, హార్డ్‌వేర్ స్థానిక కోడ్‌ను అమలు చేయగలదు, అదే విధంగా JVM బైట్‌కోడ్ యొక్క అదే క్రమాన్ని పదేపదే అర్థం చేసుకోవడంతో పాటు మరియు అనువాద ప్రక్రియ కోసం ఓవర్‌హెడ్‌ను కలిగి ఉంటుంది.
దీనితో, నేను జావా ఆర్కిటెక్చర్ పై ఈ వ్యాసం చివరలో చేరుకున్నాను. పైన చర్చించిన విషయాలు మీ జావా జ్ఞానానికి విలువను చేకూర్చాయని నేను ఆశిస్తున్నాను. మరిన్ని వ్యాసాల కోసం వేచి ఉండండి!
ఇప్పుడు మీరు జావా యొక్క ప్రాథమికాలను అర్థం చేసుకున్నారు, చూడండి ప్రపంచవ్యాప్తంగా విస్తరించి ఉన్న 250,000 మందికి పైగా సంతృప్తికరమైన అభ్యాసకుల నెట్‌వర్క్‌తో విశ్వసనీయ ఆన్‌లైన్ లెర్నింగ్ సంస్థ ఎడురేకా చేత. ఎడురేకా యొక్క జావా J2EE మరియు SOA శిక్షణ మరియు ధృవీకరణ కోర్సు జావా డెవలపర్‌గా ఉండాలనుకునే విద్యార్థులు మరియు నిపుణుల కోసం రూపొందించబడింది. ఈ కోర్సు మీకు జావా ప్రోగ్రామింగ్‌లోకి రావడానికి మరియు హైబర్నేట్ & స్ప్రింగ్ వంటి వివిధ జావా ఫ్రేమ్‌వర్క్‌లతో పాటు కోర్ మరియు అడ్వాన్స్‌డ్ జావా కాన్సెప్ట్‌లకు శిక్షణ ఇవ్వడానికి రూపొందించబడింది.
మాకు ప్రశ్న ఉందా? దయచేసి ఈ “జావా ఆర్కిటెక్చర్ మరియు దాని భాగాలు” బ్లాగ్ యొక్క వ్యాఖ్యల విభాగంలో పేర్కొనండి మరియు మేము వీలైనంత త్వరగా మిమ్మల్ని సంప్రదిస్తాము.