ஜாவா கோர்க்கான சிறந்த 50 வேலை நேர்காணல் கேள்விகள் மற்றும் பதில்கள். பகுதி 2

ஜாவா கோர்க்கான சிறந்த 50 வேலை நேர்காணல் கேள்விகள் மற்றும் பதில்கள். பகுதி 1

மல்டித்ரெடிங்

24. ஜாவாவில் புதிய நூலை எவ்வாறு உருவாக்குவது?

ஒரு வழி அல்லது வேறு, நூல் வகுப்பைப் பயன்படுத்தி ஒரு நூல் உருவாக்கப்படுகிறது. ஆனால் இதைச் செய்ய பல்வேறு வழிகள் உள்ளன ...

1. java.lang.Thread ஐப் பெறவும் .
2. java.lang.Runnable interface ஐ செயல்படுத்தவும் — Thread class இன் கன்ஸ்ட்ரக்டர் ஒரு Runnable object ஐ எடுக்கிறது.

அவை ஒவ்வொன்றையும் பற்றி பேசலாம்.

நூல் வகுப்பைப் பெறுங்கள்

இந்த வழக்கில், எங்கள் வகுப்பை 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. ஸ்டார்ட்() என்று அழைக்காமல் நேரடியாக ரன்() என்று அழைத்தால் என்ன செய்வது?

ஆம், நீங்கள் நிச்சயமாக ரன்() முறையை அழைக்கலாம் , ஆனால் புதிய நூல் உருவாக்கப்படாது, மேலும் அந்த முறை தனி நூலில் இயங்காது. இந்த வழக்கில், நாம் ஒரு சாதாரண பொருளை ஒரு சாதாரண முறையை அழைக்கிறோம். நாம் தொடக்க () முறையைப் பற்றி பேசினால் , அது வேறு விஷயம். இந்த முறை அழைக்கப்படும்போது, ​​​​ஜேவிஎம் ஒரு புதிய தொடரைத் தொடங்குகிறது. இந்த நூல், எங்கள் முறையை அழைக்கிறது ;) நம்பவில்லையா? இதோ, முயற்சிக்கவும்:

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. பணிநிறுத்தம் கொக்கி என்றால் என்ன?

ஷட் டவுன் ஹூக் என்பது ஜாவா மெய்நிகர் இயந்திரம் (ஜேவிஎம்) மூடப்படுவதற்கு முன் மறைமுகமாக அழைக்கப்படும் ஒரு நூல் ஆகும். எனவே, ஜாவா மெய்நிகர் இயந்திரம் சாதாரணமாக அல்லது அசாதாரணமாக மூடப்படும் போது, ​​ஒரு ஆதாரத்தை வெளியிட அல்லது நிலையை சேமிக்க இதைப் பயன்படுத்தலாம். பின்வரும் முறையைப் பயன்படுத்தி நாம் ஒரு பணிநிறுத்தம் ஹூக்கைச் சேர்க்கலாம் :

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. முட்டுக்கட்டை என்றால் என்ன?

ஜாவாவில், டெட்லாக் என்பது மல்டித்ரெடிங்கின் ஒரு பகுதியாக நடக்கக்கூடிய ஒன்று. ஒரு நூல் மற்றொரு நூலால் பெறப்பட்ட பொருளின் பூட்டுக்காக காத்திருக்கும் போது ஒரு முட்டுக்கட்டை ஏற்படலாம், மேலும் இரண்டாவது நூல் முதல் நூலால் பெறப்பட்ட பொருளின் பூட்டுக்காக காத்திருக்கிறது. இதன் பொருள் இரண்டு இழைகளும் ஒன்றுக்கொன்று காத்திருக்கின்றன, மேலும் அவற்றின் குறியீட்டை செயல்படுத்துவது தொடர முடியாது. Runnable ஐச் செயல்படுத்தும் வகுப்பைக் கொண்ட ஒரு உதாரணத்தைக் கருத்தில் கொள்வோம். அதன் கட்டமைப்பாளர் இரண்டு ஆதாரங்களை எடுத்துக்கொள்கிறார். ரன்() முறை அவற்றுக்கான பூட்டை வரிசையாகப் பெறுகிறது. நீங்கள் இந்த வகுப்பின் இரண்டு பொருட்களை உருவாக்கி, வளங்களை வேறு வரிசையில் அனுப்பினால், நீங்கள் எளிதாக முட்டுக்கட்டைக்குள் செல்லலாம்:

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() ஐப் பயன்படுத்துதல் . ஒரு இழை மற்றொன்றிற்காக காத்திருக்கும் போது நீங்கள் முட்டுக்கட்டைக்குள் ஓடலாம். இந்தச் சிக்கலைத் தவிர்க்க, join() முறைக்கான காலக்கெடுவை அமைக்கலாம் .
• எங்களிடம் ஒரு நூல் இருந்தால், எந்த முட்டுக்கட்டையும் இருக்காது;)

37. இனம் நிலை என்றால் என்ன?

நிஜ வாழ்க்கை பந்தயங்கள் கார்களை உள்ளடக்கியிருந்தால், மல்டித்ரெடிங்கில் உள்ள பந்தயங்களில் நூல்கள் அடங்கும். ஆனால் ஏன்? :/ ஒரே பொருளை அணுகக்கூடிய இரண்டு இழைகள் இயங்குகின்றன. அவர்கள் ஒரே நேரத்தில் பகிரப்பட்ட பொருளின் நிலையைப் புதுப்பிக்க முயற்சிக்கலாம். இதுவரை எல்லாம் தெளிவாக உள்ளது, இல்லையா? த்ரெட்கள் இணையாக (செயலி ஒன்றுக்கும் மேற்பட்ட கோர்களைக் கொண்டிருந்தால்) அல்லது தொடர்ச்சியாக, செயலி இடைப்பட்ட நேரத் துண்டுகளை ஒதுக்குவதன் மூலம் செயல்படுத்தப்படுகிறது. இந்த செயல்முறைகளை எங்களால் நிர்வகிக்க முடியாது. இதன் பொருள் என்னவென்றால், ஒரு த்ரெட் ஒரு பொருளிலிருந்து தரவைப் படிக்கும் போது, ​​வேறு சில நூல்கள் அவ்வாறு செய்வதற்கு முன், பொருளை மாற்றுவதற்கு நேரம் கிடைக்கும் என்று எங்களால் உத்தரவாதம் அளிக்க முடியாது. இந்த "செக்-அண்ட்-ஆக்ட்" காம்போக்கள் இருக்கும் போது இதுபோன்ற பிரச்சனைகள் எழுகின்றன. அதற்கு என்ன பொருள்? if-conditionஐயே உடலே மாற்றும் if அறிக்கை நம்மிடம் இருப்பதாக வைத்துக்கொள்வோம் , எடுத்துக்காட்டாக:

int z = 0;

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

z இன்னும் பூஜ்ஜியமாக இருக்கும் போது இரண்டு த்ரெட்கள் ஒரே நேரத்தில் இந்தக் குறியீட்டுத் தொகுதியை உள்ளிடலாம், பின்னர் இரண்டு திரிகளும் அதன் மதிப்பை மாற்றலாம். இதன் விளைவாக, நாம் எதிர்பார்க்கும் மதிப்பான 5 ஐப் பெற முடியாது. அதற்குப் பதிலாக, நமக்கு 10 கிடைக்கும். இதை எப்படித் தவிர்ப்பது? சரிபார்த்து செயல்படுவதற்கு முன் நீங்கள் ஒரு பூட்டைப் பெற வேண்டும், பின்னர் பூட்டை விடுவிக்க வேண்டும். அதாவது, நீங்கள் முதல் நூலை if பிளாக்கிற்குள் நுழைய வேண்டும் , அனைத்து செயல்களையும் செய்து, z ஐ மாற்ற வேண்டும் , அதன் பிறகுதான் அடுத்த தொடரிழை அதைச் செய்வதற்கான வாய்ப்பை வழங்க வேண்டும். ஆனால் z இப்போது 5 ஆக இருப்பதால் , அடுத்த த்ரெட் if பிளாக்கில் நுழையாது :

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

ஒரு முடிவுக்கு பதிலாக

இறுதிவரை படித்த அனைவருக்கும் நன்றி சொல்ல விரும்புகிறேன். அது நீண்ட தூரம், ஆனால் நீங்கள் தாங்கிக் கொண்டீர்கள்! ஒருவேளை எல்லாம் தெளிவாக இல்லை. இது சாதாரணமானது. நான் முதலில் ஜாவாவைப் படிக்கத் தொடங்கியபோது, ​​நிலையான மாறி என்றால் என்ன என்பதைச் சுற்றி என் மூளையைச் சுற்றி வர முடியவில்லை. ஆனால் பெரிய விஷயமில்லை. நான் அதில் தூங்கினேன், இன்னும் சில ஆதாரங்களைப் படித்தேன், பின்னர் புரிதல் வந்தது. ஒரு நேர்காணலுக்குத் தயாராவது என்பது ஒரு நடைமுறை கேள்வியை விட கல்வி சார்ந்த கேள்வி. இதன் விளைவாக, ஒவ்வொரு நேர்காணலுக்கு முன்பும், நீங்கள் அடிக்கடி பயன்படுத்தாத விஷயங்களை மதிப்பாய்வு செய்து உங்கள் நினைவகத்தில் புதுப்பிக்க வேண்டும்.

எப்போதும் போல, இங்கே சில பயனுள்ள இணைப்புகள் உள்ளன:

• ஜாவாவில் விதிவிலக்குகள்
• ஜாவாவில் இயல்புநிலை முறைகள்
• GitHub இல் என்னைப் பின்தொடரவும் . எனது அனைத்து கல்வி திட்டங்களையும் அங்கு வைத்தேன். நான் கற்பிக்கும் அனைத்தும். உதாரணமாக, நான் சமீபத்தில் Drools RuleEngine ஐ தோண்டி எடுத்தேன் .
• சரிபார்க்கப்படாத விதிவிலக்குகள் சரிபார்க்கப்பட்டன
• முயற்சி-வளங்களுடன்
• இறுதி முக்கிய வார்த்தை
• இந்தக் கட்டுரையைத் தயாரிக்கும் போது, ​​https://www.geeksforgeeks.org என்ற இணையதளம் எனக்கு மிகவும் பிடித்திருந்தது . அங்கே நிறைய அருமையான தகவல்கள் உள்ளன.

படித்த அனைவருக்கும் நன்றி. விரைவில் சந்திப்போம் :) எனது GitHub சுயவிவரம்