జావా కోర్ కోసం టాప్ 50 ఉద్యోగ ఇంటర్వ్యూ ప్రశ్నలు మరియు సమాధానాలు. పార్ట్ 2

జావా కోర్ కోసం టాప్ 50 ఉద్యోగ ఇంటర్వ్యూ ప్రశ్నలు మరియు సమాధానాలు. 1 వ భాగము

మల్టీథ్రెడింగ్

24. నేను జావాలో కొత్త థ్రెడ్‌ని ఎలా సృష్టించగలను?

ఒక మార్గం లేదా మరొకటి, థ్రెడ్ క్లాస్ ఉపయోగించి థ్రెడ్ సృష్టించబడుతుంది. కానీ దీన్ని చేయడానికి వివిధ మార్గాలు ఉన్నాయి…

1. inherit java.lang.Thread .
2. java.lang.Runnable ఇంటర్‌ఫేస్‌ని అమలు చేయండి — థ్రెడ్ క్లాస్ యొక్క కన్స్ట్రక్టర్ రన్ చేయదగిన వస్తువును తీసుకుంటుంది.

వాటిలో ప్రతి దాని గురించి మాట్లాడుకుందాం.

థ్రెడ్ తరగతిని వారసత్వంగా పొందండి

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

/**
* An example of how to create threads by inheriting the {@link Thread} class.
*/
class ThreadInheritance extends Thread {

   @Override
   public void run() {
       System.out.println(Thread.currentThread().getName());
   }

   public static void main(String[] args) {
       ThreadInheritance threadInheritance1 = new ThreadInheritance();
       ThreadInheritance threadInheritance2 = new ThreadInheritance();
       ThreadInheritance threadInheritance3 = new ThreadInheritance();
       threadInheritance1.start();
       threadInheritance2.start();
       threadInheritance3.start();
   }
}

కన్సోల్ అవుట్‌పుట్ ఇలా ఉంటుంది: అంటే, ఇక్కడ కూడా థ్రెడ్‌లు క్రమంలో కాకుండా, వాటిని అమలు చేయడానికి JVM సరిపోతుందని భావిస్తున్నట్లు మనం చూస్తాము :)

రన్ చేయదగిన ఇంటర్‌ఫేస్‌ను అమలు చేయండి

మీరు వారసత్వానికి వ్యతిరేకంగా ఉంటే మరియు/లేదా ఇప్పటికే కొన్ని ఇతర తరగతిని వారసత్వంగా పొందినట్లయితే, మీరు java.lang.Runnable ఇంటర్‌ఫేస్‌ని ఉపయోగించవచ్చు . ఇక్కడ, పైన ఉదాహరణలో వలె, రన్() పద్ధతిని అమలు చేయడం ద్వారా మన తరగతి ఈ ఇంటర్‌ఫేస్‌ని అమలు చేసేలా చేస్తాము . థ్రెడ్ వస్తువులను సృష్టించడం మాత్రమే మిగిలి ఉంది . కోడ్ యొక్క మరిన్ని పంక్తులు అధ్వాన్నంగా ఉన్నట్లు అనిపిస్తుంది. కానీ వారసత్వం ఎంత హానికరమో మరియు దానిని అన్ని విధాలుగా నివారించడం మంచిదని మాకు తెలుసు ;) ఒకసారి చూడండి:

/**
* An example of how to create threads from the {@link Runnable} interface.
* It's easier than easy — we implement this interface and then pass an instance of our object
* to the constructor.
*/
class ThreadInheritance implements Runnable {

   @Override
   public void run() {
       System.out.println(Thread.currentThread().getName());
   }

   public static void main(String[] args) {
       ThreadInheritance runnable1 = new ThreadInheritance();
       ThreadInheritance runnable2 = new ThreadInheritance();
       ThreadInheritance runnable3 = new ThreadInheritance();

       Thread threadRunnable1 = new Thread(runnable1);
       Thread threadRunnable2 = new Thread(runnable2);
       Thread threadRunnable3 = new Thread(runnable3);

       threadRunnable1.start();
       threadRunnable2.start();
       threadRunnable3.start();
   }
}

మరియు ఇక్కడ ఫలితం ఉంది:

25. ప్రక్రియ మరియు థ్రెడ్ మధ్య తేడా ఏమిటి?

ఒక ప్రక్రియ మరియు థ్రెడ్ క్రింది మార్గాలలో విభిన్నంగా ఉంటాయి:

1. నడుస్తున్న ప్రోగ్రామ్‌ను ప్రాసెస్ అంటారు, కానీ థ్రెడ్ అనేది ప్రక్రియ యొక్క భాగం.
2. ప్రక్రియలు స్వతంత్రమైనవి, కానీ థ్రెడ్‌లు ప్రక్రియ యొక్క భాగాలు.
3. ప్రక్రియలు మెమరీలో వేర్వేరు చిరునామా ఖాళీలను కలిగి ఉంటాయి, కానీ థ్రెడ్‌లు సాధారణ చిరునామా స్థలాన్ని పంచుకుంటాయి.
4. థ్రెడ్‌ల మధ్య సందర్భ మార్పిడి ప్రక్రియల మధ్య మారడం కంటే వేగంగా ఉంటుంది.
5. ఇంటర్-థ్రెడ్ కమ్యూనికేషన్ కంటే ఇంటర్-ప్రాసెస్ కమ్యూనికేషన్ నెమ్మదిగా ఉంటుంది మరియు ఖరీదైనది.
6. పేరెంట్ ప్రాసెస్‌లో ఏవైనా మార్పులు చైల్డ్ ప్రాసెస్‌ని ప్రభావితం చేయవు, కానీ పేరెంట్ థ్రెడ్‌లో మార్పులు చైల్డ్ థ్రెడ్‌ను ప్రభావితం చేస్తాయి.

26. మల్టీథ్రెడింగ్ యొక్క ప్రయోజనాలు ఏమిటి?

1. మల్టీథ్రెడింగ్ అనేది అప్లికేషన్/ప్రోగ్రామ్ ఇప్పటికే కొన్ని బ్యాక్‌గ్రౌండ్ టాస్క్‌లను అమలు చేస్తున్నప్పటికీ, ఇన్‌పుట్‌కు ఎల్లప్పుడూ ప్రతిస్పందించేలా అనుమతిస్తుంది;
2. మల్టీథ్రెడింగ్ పనులు వేగంగా పూర్తి చేయడం సాధ్యం చేస్తుంది, ఎందుకంటే థ్రెడ్‌లు స్వతంత్రంగా నడుస్తాయి;
3. మల్టీథ్రెడింగ్ కాష్ మెమరీని మెరుగైన ఉపయోగాన్ని అందిస్తుంది, ఎందుకంటే థ్రెడ్‌లు షేర్డ్ మెమరీ వనరులను యాక్సెస్ చేయగలవు;
4. మల్టీథ్రెడింగ్ అవసరమైన సర్వర్‌ల సంఖ్యను తగ్గిస్తుంది, ఎందుకంటే ఒక సర్వర్ బహుళ థ్రెడ్‌లను ఏకకాలంలో అమలు చేయగలదు.

27. థ్రెడ్ యొక్క జీవిత చక్రంలోని రాష్ట్రాలు ఏమిటి?

1. కొత్తది: ఈ స్థితిలో, కొత్త ఆపరేటర్‌ని ఉపయోగించి థ్రెడ్ ఆబ్జెక్ట్ సృష్టించబడుతుంది, కానీ కొత్త థ్రెడ్ ఇంకా ఉనికిలో లేదు. మేము ప్రారంభ () పద్ధతిని పిలిచే వరకు థ్రెడ్ ప్రారంభం కాదు .
2. రన్ చేయదగినది: ఈ స్థితిలో, థ్రెడ్ ప్రారంభం() తర్వాత అమలు చేయడానికి సిద్ధంగా ఉంది. పద్ధతి అంటారు. అయితే, ఇది ఇంకా థ్రెడ్ షెడ్యూలర్ ద్వారా ఎంపిక కాలేదు.
3. రన్నింగ్: ఈ స్థితిలో, థ్రెడ్ షెడ్యూలర్ సిద్ధంగా ఉన్న స్థితి నుండి థ్రెడ్‌ను ఎంచుకుంటుంది మరియు అది నడుస్తుంది.
4. వేచి ఉంది/బ్లాక్ చేయబడింది: ఈ స్థితిలో, ఒక థ్రెడ్ అమలులో లేదు, కానీ అది ఇప్పటికీ సజీవంగా ఉంది లేదా మరొక థ్రెడ్ పూర్తయ్యే వరకు వేచి ఉంది.
5. డెడ్/టెర్మినేటెడ్: థ్రెడ్ రన్() పద్ధతి నుండి నిష్క్రమించినప్పుడు, అది చనిపోయిన లేదా ముగించబడిన స్థితిలో ఉంటుంది.

28. ఒక థ్రెడ్‌ను రెండుసార్లు అమలు చేయడం సాధ్యమేనా?

లేదు, మేము థ్రెడ్‌ను పునఃప్రారంభించలేము, ఎందుకంటే థ్రెడ్ ప్రారంభించి, రన్ అయిన తర్వాత, అది డెడ్ స్థితికి వెళుతుంది. మేము థ్రెడ్‌ను రెండుసార్లు ప్రారంభించేందుకు ప్రయత్నిస్తే, java.lang.IllegalThreadStateException విసిరివేయబడుతుంది. ఒకసారి చూద్దాము:

class DoubleStartThreadExample extends Thread {

   /**
    * Simulate the work of a thread
    */
   public void run() {
	// Something happens. At this state, this is not essential.
   }

   /**
    * Start the thread twice
    */
   public static void main(String[] args) {
       DoubleStartThreadExample doubleStartThreadExample = new DoubleStartThreadExample();
       doubleStartThreadExample.start();
       doubleStartThreadExample.start();
   }
}

అదే థ్రెడ్ యొక్క రెండవ ప్రారంభానికి ఎగ్జిక్యూషన్ వచ్చిన వెంటనే మినహాయింపు ఉంటుంది. మీరే ప్రయత్నించండి ;) దీని గురించి వందసార్లు వినడం కంటే ఒకసారి చూడటం మంచిది.

29. మీరు start() అని పిలవకుండా నేరుగా రన్()కి కాల్ చేస్తే?

అవును, మీరు ఖచ్చితంగా రన్() పద్ధతిని కాల్ చేయవచ్చు , కానీ కొత్త థ్రెడ్ సృష్టించబడదు మరియు పద్ధతి ప్రత్యేక థ్రెడ్‌లో అమలు చేయబడదు. ఈ సందర్భంలో, మనకు సాధారణ పద్ధతిని పిలిచే ఒక సాధారణ వస్తువు ఉంది. మేము ప్రారంభ () పద్ధతి గురించి మాట్లాడినట్లయితే , అది మరొక విషయం. ఈ పద్ధతిని పిలిచినప్పుడు, JVM కొత్త థ్రెడ్‌ను ప్రారంభిస్తుంది. ఈ థ్రెడ్, క్రమంగా, మా పద్ధతిని పిలుస్తుంది ;) నమ్మలేదా? ఇక్కడ, ఒకసారి ప్రయత్నించండి:

class ThreadCallRunExample extends Thread {

   public void run() {
       for (int i = 0; i < 5; i++) {
           System.out.print(i);
       }
   }

   public static void main(String args[]) {
       ThreadCallRunExample runExample1 = new ThreadCallRunExample();
       ThreadCallRunExample runExample2 = new ThreadCallRunExample();

       // Two ordinary methods will be called in the main thread, one after the other.
       runExample1.run();
       runExample2.run();
   }
}

మరియు కన్సోల్ అవుట్‌పుట్ ఇలా ఉంటుంది: మీరు గమనిస్తే, ఏ థ్రెడ్ సృష్టించబడలేదు. అంతా సాధారణ తరగతిలో మాదిరిగానే పనిచేశారు. మొదట, మొదటి వస్తువు యొక్క పద్ధతి అమలు చేయబడింది, ఆపై రెండవది.

30. డెమోన్ థ్రెడ్ అంటే ఏమిటి?

డెమోన్ థ్రెడ్ అనేది మరొక థ్రెడ్ కంటే తక్కువ ప్రాధాన్యతతో పనులను చేసే థ్రెడ్. మరో మాటలో చెప్పాలంటే, మరొక (ప్రధాన) థ్రెడ్‌తో కలిపి మాత్రమే చేయవలసిన సహాయక పనులను చేయడం దీని పని. చెత్త సేకరణ, ఫైనలైజర్ మొదలైన అనేక డెమోన్ థ్రెడ్‌లు ఆటోమేటిక్‌గా అమలవుతాయి.

జావా డెమోన్ థ్రెడ్‌ను ఎందుకు ముగించింది?

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

థ్రెడ్ క్లాస్ యొక్క పద్ధతులు

java.lang.Thread క్లాస్ డెమోన్ థ్రెడ్‌తో పని చేయడానికి రెండు పద్ధతులను అందిస్తుంది :

1. public void setDaemon(బూలియన్ స్థితి) — ఇది డెమోన్ థ్రెడ్ కాదా అని ఈ పద్ధతి సూచిస్తుంది. డిఫాల్ట్ తప్పు . మీరు ప్రత్యేకంగా చెబితే తప్ప డెమోన్ థ్రెడ్‌లు సృష్టించబడవని దీని అర్థం.
2. public boolean isDaemon() — ఈ పద్ధతి తప్పనిసరిగా డెమోన్ వేరియబుల్ కోసం గెటర్ , మేము మునుపటి పద్ధతిని ఉపయోగించి సెట్ చేసాము.

ఉదాహరణ:

class DaemonThreadExample extends Thread {

   public void run() {
       // Checks whether this thread is a daemon
       if (Thread.currentThread().isDaemon()) {
           System.out.println("daemon thread");
       } else {
           System.out.println("user thread");
       }
   }

   public static void main(String[] args) {
       DaemonThreadExample thread1 = new DaemonThreadExample();
       DaemonThreadExample thread2 = new DaemonThreadExample();
       DaemonThreadExample thread3 = new DaemonThreadExample();

       // Make thread1 a daemon thread.
       thread1.setDaemon(true);

       System.out.println("daemon? " + thread1.isDaemon());
       System.out.println("daemon? " + thread2.isDaemon());
       System.out.println("daemon? " + thread3.isDaemon());

       thread1.start();
       thread2.start();
       thread3.start();
   }
}

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

31. థ్రెడ్‌ని సృష్టించిన తర్వాత డెమోన్‌గా చేయడం సాధ్యమేనా?

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

class SetDaemonAfterStartExample extends Thread {

   public void run() {
       System.out.println("Working...");
   }

   public static void main(String[] args) {
       SetDaemonAfterStartExample afterStartExample = new SetDaemonAfterStartExample();
       afterStartExample.start();

       // An exception will be thrown here
       afterStartExample.setDaemon(true);
   }
}

కన్సోల్ అవుట్‌పుట్:

32. షట్డౌన్ హుక్ అంటే ఏమిటి?

షట్‌డౌన్ హుక్ అనేది జావా వర్చువల్ మెషీన్ (JVM) షట్ డౌన్ చేయబడే ముందు పరోక్షంగా పిలువబడే థ్రెడ్. అందువల్ల, జావా వర్చువల్ మెషీన్ సాధారణంగా లేదా అసాధారణంగా ఆపివేయబడినప్పుడు వనరును విడుదల చేయడానికి లేదా స్థితిని సేవ్ చేయడానికి మేము దానిని ఉపయోగించవచ్చు. మేము క్రింది పద్ధతిని ఉపయోగించి షట్‌డౌన్ హుక్‌ని జోడించవచ్చు :

Runtime.getRuntime().addShutdownHook(new ShutdownHookThreadExample());

ఉదాహరణలో చూపిన విధంగా:

/**
* A program that shows how to start a shutdown hook thread,
* which will be executed right before the JVM shuts down
*/
class ShutdownHookThreadExample extends Thread {

   public void run() {
       System.out.println("shutdown hook executed");
   }

   public static void main(String[] args) {

       Runtime.getRuntime().addShutdownHook(new ShutdownHookThreadExample());

       System.out.println("Now the program is going to fall asleep. Press Ctrl+C to terminate it.");
       try {
           Thread.sleep(60000);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
   }
}

కన్సోల్ అవుట్‌పుట్:

33. సమకాలీకరణ అంటే ఏమిటి?

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

• ఒక పద్ధతిని సమకాలీకరించడం
• నిర్దిష్ట బ్లాక్‌ను సమకాలీకరించడం
• స్టాటిక్ సింక్రొనైజేషన్

ఒక పద్ధతిని సమకాలీకరించడం

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

/**
* An example where we synchronize a method. That is, we add the synchronized keyword to it.
* There are two authors who want to use one printer. Each of them has composed their own poems
* And of course they don’t want their poems mixed up. Instead, they want work to be performed in * * * order for each of them
*/
class Printer {

   synchronized void print(List<String> wordsToPrint) {
       wordsToPrint.forEach(System.out::print);
       System.out.println();
   }

   public static void main(String args[]) {
       // One object for two threads
       Printer printer  = new Printer();

       // Create two threads
       Writer1 writer1 = new Writer1(printer);
       Writer2 writer2 = new Writer2(printer);

       // Start them
       writer1.start();
       writer2.start();
   }
}

/**
* Author No. 1, who writes an original poem.
*/
class Writer1 extends Thread {
   Printer printer;

   Writer1(Printer printer) {
       this.printer = printer;
   }

   public void run() {
       List<string> poem = Arrays.asList("I ", this.getName(), " Write", " A Letter");
       printer.print(poem);
   }

}

/**
* Author No. 2, who writes an original poem.
*/
class Writer2 extends Thread {
   Printer printer;

   Writer2(Printer printer) {
       this.printer = printer;
   }

   public void run() {
       List<String> poem = Arrays.asList("I Do Not ", this.getName(), " Not Write", " No Letter");
       printer.print(poem);
   }
}

మరియు కన్సోల్ అవుట్‌పుట్ ఇది:

సమకాలీకరణ బ్లాక్

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

synchronized ("object to be locked") {
   // The code that must be protected
}

మునుపటి ఉదాహరణ పునరావృతం కాకుండా ఉండటానికి, మేము అనామక తరగతులను ఉపయోగించి థ్రెడ్‌లను సృష్టిస్తాము, అనగా మేము వెంటనే అమలు చేయగల ఇంటర్‌ఫేస్‌ను అమలు చేస్తాము.

/**
* This is how a synchronization block is added.
* Inside the block, you need to specify which object's mutex will be acquired.
*/
class Printer {

   void print(List<String> wordsToPrint) {
       synchronized (this) {
           wordsToPrint.forEach(System.out::print);
       }
       System.out.println();
   }

   public static void main(String args[]) {
       // One object for two threads
       Printer printer = new Printer();

       // Create two threads
       Thread writer1 = new Thread(new Runnable() {
           @Override
           public void run() {
               List<String> poem = Arrays.asList("I ", "Writer1", " Write", " A Letter");
               printer.print(poem);
           }
       });
       Thread writer2 = new Thread(new Runnable() {
           @Override
           public void run() {
               List<String> poem = Arrays.asList("I Do Not ", "Writer2", " Not Write", " No Letter");
               printer.print(poem);
           }
       });

       // Start them
       writer1.start();
       writer2.start();
   }
}

}

మరియు కన్సోల్ అవుట్‌పుట్ ఇది:

స్టాటిక్ సింక్రొనైజేషన్

మీరు స్టాటిక్ పద్ధతిని సమకాలీకరించినట్లయితే, లాకింగ్ అనేది వస్తువుపై కాకుండా తరగతిపై జరుగుతుంది. ఈ ఉదాహరణలో, మేము సమకాలీకరించబడిన కీవర్డ్‌ను స్టాటిక్ పద్ధతికి వర్తింపజేయడం ద్వారా స్టాటిక్ సింక్రొనైజేషన్ చేస్తాము:

/**
* This is how a synchronization block is added.
* Inside the block, you need to specify which object's mutex will be acquired.
*/
class Printer {

   static synchronized void print(List<String> wordsToPrint) {
       wordsToPrint.forEach(System.out::print);
       System.out.println();
   }

   public static void main(String args[]) {

       // Create two threads
       Thread writer1 = new Thread(new Runnable() {
           @Override
           public void run() {
               List<String> poem = Arrays.asList("I ", "Writer1", " Write", " A Letter");
               Printer.print(poem);
           }
       });
       Thread writer2 = new Thread(new Runnable() {
           @Override
           public void run() {
               List<String> poem = Arrays.asList("I Do Not ", "Writer2", " Not Write", " No Letter");
               Printer.print(poem);
           }
       });

       // Start them
       writer1.start();
       writer2.start();
   }
}

మరియు కన్సోల్ అవుట్‌పుట్ ఇది:

34. అస్థిర చరరాశి అంటే ఏమిటి?

మల్టీథ్రెడ్ ప్రోగ్రామింగ్‌లో, థ్రెడ్ భద్రత కోసం అస్థిర కీవర్డ్ ఉపయోగించబడుతుంది. మార్చగల వేరియబుల్ సవరించబడినప్పుడు, మార్పు అన్ని ఇతర థ్రెడ్‌లకు కనిపిస్తుంది, కాబట్టి ఒక వేరియబుల్‌ను ఒక సమయంలో ఒక థ్రెడ్ ద్వారా ఉపయోగించవచ్చు. అస్థిరమైన కీవర్డ్‌ని ఉపయోగించడం ద్వారా , వేరియబుల్ థ్రెడ్-సురక్షితమని మరియు షేర్డ్ మెమరీలో నిల్వ చేయబడిందని మరియు థ్రెడ్‌లు దానిని వాటి కాష్‌లలో నిల్వ చేయవని మీరు హామీ ఇవ్వవచ్చు. ఇది ఎలా కనిపిస్తుంది?

private volatile AtomicInteger count;

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

35. డెడ్‌లాక్ అంటే ఏమిటి?

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

class DeadLock {

   public static void main(String[] args) {
       final Integer r1 = 10;
       final Integer r2 = 15;

       DeadlockThread threadR1R2 = new DeadlockThread(r1, r2);
       DeadlockThread threadR2R1 = new DeadlockThread(r2, r1);

       new Thread(threadR1R2).start();
       new Thread(threadR2R1).start();
   }
}

/**
* A class that accepts two resources.
*/
class DeadlockThread implements Runnable {

   private final Integer r1;
   private final Integer r2;

   public DeadlockThread(Integer r1, Integer r2) {
       this.r1 = r1;
       this.r2 = r2;
   }

   @Override
   public void run() {
       synchronized (r1) {
           System.out.println(Thread.currentThread().getName() + " acquired resource: " + r1);

           try {
               Thread.sleep(1000);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }

           synchronized (r2) {
               System.out.println(Thread.currentThread().getName() + " acquired resource: " + r2);
           }
       }
   }
}

కన్సోల్ అవుట్‌పుట్:

36. మీరు ప్రతిష్టంభనను ఎలా నివారించాలి?

ప్రతిష్టంభన ఎలా ఏర్పడుతుందో మాకు తెలుసు కాబట్టి, మనం కొన్ని తీర్మానాలను తీసుకోవచ్చు...

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

37. జాతి పరిస్థితి అంటే ఏమిటి?

నిజ జీవిత రేసుల్లో కార్లు ఉంటే, మల్టీథ్రెడింగ్‌లోని రేసుల్లో థ్రెడ్‌లు ఉంటాయి. కానీ ఎందుకు? :/ రెండు థ్రెడ్‌లు అమలులో ఉన్నాయి మరియు ఒకే వస్తువును యాక్సెస్ చేయగలవు. మరియు వారు ఒకే సమయంలో భాగస్వామ్య వస్తువు యొక్క స్థితిని నవీకరించడానికి ప్రయత్నించవచ్చు. ఇప్పటివరకు ప్రతిదీ స్పష్టంగా ఉంది, సరియైనదా? థ్రెడ్‌లు అక్షరాలా సమాంతరంగా (ప్రాసెసర్ ఒకటి కంటే ఎక్కువ కోర్లను కలిగి ఉంటే) లేదా వరుసగా, ప్రాసెసర్ ఇంటర్‌లీవ్డ్ టైమ్ స్లైస్‌లను కేటాయించడంతో అమలు చేయబడతాయి. మేము ఈ ప్రక్రియలను నిర్వహించలేము. దీనర్థం ఏమిటంటే, ఒక థ్రెడ్ ఒక వస్తువు నుండి డేటాను చదివినప్పుడు, ఏదైనా ఇతర థ్రెడ్ అలా చేసే ముందు ఆబ్జెక్ట్‌ను మార్చడానికి సమయం ఉంటుందని మేము హామీ ఇవ్వలేము. మనకు ఈ "చెక్-అండ్-యాక్ట్" కాంబోలు ఉన్నప్పుడు ఇటువంటి సమస్యలు తలెత్తుతాయి. అంటే ఏమిటి? మనకు if స్టేట్‌మెంట్ ఉందని అనుకుందాం, దీని శరీరం if-కండిషన్‌ను మార్చుకుంటుంది, ఉదాహరణకు:

int z = 0;

// Check
if (z < 5) {
// Act
   z = z + 5;
}

z సున్నాగా ఉన్నప్పుడు రెండు థ్రెడ్‌లు ఏకకాలంలో ఈ కోడ్ బ్లాక్‌ని నమోదు చేయగలవు మరియు రెండు థ్రెడ్‌లు దాని విలువను మార్చగలవు. ఫలితంగా, మేము ఆశించిన 5 విలువను పొందలేము. బదులుగా, మనకు 10 వస్తుంది. మీరు దీన్ని ఎలా నివారించాలి? మీరు తనిఖీ చేసి, నటించే ముందు లాక్‌ని పొందాలి, ఆపై లాక్‌ని విడుదల చేయాలి. అంటే, మీరు మొదటి థ్రెడ్‌ను if బ్లాక్‌లో నమోదు చేయాలి , అన్ని చర్యలను చేయాలి, z మార్చాలి , ఆపై మాత్రమే తదుపరి థ్రెడ్‌కు కూడా అదే విధంగా చేసే అవకాశం ఇవ్వాలి. కానీ తదుపరి థ్రెడ్ if బ్లాక్‌లోకి ప్రవేశించదు , ఎందుకంటే z ఇప్పుడు 5 అవుతుంది:

// Acquire the lock for z
if (z < 5) {
   z = z + 5;
}
// Release z's lock
===================================================

ముగింపుకు బదులుగా

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

మరియు ఎప్పటిలాగే, ఇక్కడ కొన్ని ఉపయోగకరమైన లింక్‌లు ఉన్నాయి:

• జావాలో మినహాయింపులు
• జావాలో డిఫాల్ట్ పద్ధతులు
• GitHubలో నన్ను అనుసరించండి . నేను నా విద్యా ప్రాజెక్టులన్నింటినీ అక్కడ ఉంచాను. నేను బోధించే ప్రతిదీ. ఉదాహరణకు, నేను ఇటీవల Drools RuleEngine లో త్రవ్వించాను .
• ఎంపిక చేయని మినహాయింపులను తనిఖీ చేసారు
• వనరులతో ప్రయత్నించండి
• చివరి కీవర్డ్
• నేను ఈ కథనాన్ని సిద్ధం చేస్తున్నప్పుడు, నేను https://www.geeksforgeeks.org వెబ్‌సైట్‌ని నిజంగా ఇష్టపడ్డాను . అక్కడ చాలా చక్కని సమాచారం ఉంది.

చదివినందుకు మీ అందరికీ ధన్యవాదాలు. త్వరలో కలుద్దాం :) నా GitHub ప్రొఫైల్