மல்டித்ரெடிங்: நூல் வகுப்பின் முறைகள் என்ன செய்கின்றன

வணக்கம்! இன்று நாம் மல்டித்ரெடிங் பற்றி தொடர்ந்து பேசுவோம். நூல் வகுப்பையும் அதன் சில முறைகள் என்ன செய்கின்றன என்பதையும் ஆராய்வோம். நாங்கள் முன்பு வகுப்பு முறைகளைப் படித்தபோது, ​​​​வழக்கமாக இதை எழுதினோம்: <முறையின் பெயர்> -> <முறை என்ன செய்கிறது>. இது இன் முறைகளுடன் வேலை செய்யாது Thread:) சில எடுத்துக்காட்டுகள் இல்லாமல் உங்களால் கண்டுபிடிக்க முடியாத சிக்கலான தர்க்கங்கள் உள்ளன.

Thread.start() முறை

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

public class MyFirstThread extends Thread {

   @Override
   public void run() {
       System.out.println("Thread executed: " + getName());
   }
}


public class Main {

   public static void main(String[] args) {

       for (int i = 0; i < 10; i++) {
           MyFirstThread thread = new MyFirstThread();
           thread.start();
       }
   }
}

குறிப்பு: ஒரு திரியைத் தொடங்க, நீங்கள்start()விட சிறப்பு முறையைrun()! இது ஒரு எளிதான பிழையாகும், குறிப்பாக நீங்கள் முதலில் மல்டித்ரெடிங்கைப் படிக்கத் தொடங்கும் போது. run()எங்கள் எடுத்துக்காட்டில், முறைக்கு பதிலாக 10 முறைஅழைத்தால்start(), நீங்கள் இதைப் பெறுவீர்கள்:

public class Main {

   public static void main(String[] args) {

       for (int i = 0; i < 10; i++) {
           MyFirstThread thread = new MyFirstThread();
           thread.run();
       }
   }
}

எங்கள் நிரலின் முடிவுகளைப் பார்க்கவும்: த்ரெட் செயல்படுத்தப்பட்டது: த்ரெட்-0 த்ரெட் செயல்படுத்தப்பட்டது: த்ரெட்-1 த்ரெட் செயல்படுத்தப்பட்டது: த்ரெட்-2 த்ரெட் செயல்படுத்தப்பட்டது: த்ரெட்-3 த்ரெட் செயல்படுத்தப்பட்டது: த்ரெட்-4 த்ரெட் செயல்படுத்தப்பட்டது: த்ரெட்-5 த்ரெட் செயல்படுத்தப்பட்டது: நூல்-6 த்ரெட் செயல்படுத்தப்பட்டது: நூல்-7 த்ரெட் செயல்படுத்தப்பட்டது: நூல்-8 த்ரெட் செயல்படுத்தப்பட்டது: நூல்-9 வெளியீட்டின் வரிசையைப் பாருங்கள்: எல்லாம் சரியான வரிசையில் நடக்கிறது. வித்தியாசமானது, இல்லையா? நாங்கள் இதைப் பழக்கப்படுத்தவில்லை, ஏனென்றால் த்ரெட்கள் தொடங்கப்படும் மற்றும் செயல்படுத்தப்படும் வரிசையானது நமது இயக்க முறைமையில் உள்ள ஒரு உயர்ந்த அறிவாற்றலால் தீர்மானிக்கப்படுகிறது என்பதை நாங்கள் ஏற்கனவே அறிவோம்: நூல் திட்டமிடல். ஒருவேளை நமக்கு அதிர்ஷ்டம் கிடைத்ததா? நிச்சயமாக, இது அதிர்ஷ்டத்தைப் பற்றியது அல்ல. நிரலை இன்னும் இரண்டு முறை இயக்குவதன் மூலம் இதை நீங்கள் சரிபார்க்கலாம். என்பதை அழைப்பதுதான் பிரச்சினைrun()இந்த முறைக்கு மல்டித்ரெடிங்குடன் நேரடியாக எந்த தொடர்பும் இல்லை. இந்த வழக்கில், நிரல் மெயின் த்ரெட்டில் செயல்படுத்தப்படும், அந்த main()முறையை செயல்படுத்தும் அதே நூல். இது கன்சோலில் 10 வரிகளை தொடர்ச்சியாக அச்சிடுகிறது, அவ்வளவுதான். 10 இழைகள் தொடங்கப்படவில்லை. எனவே, எதிர்காலத்தில் இதை நினைவில் வைத்துக் கொள்ளுங்கள், தொடர்ந்து உங்களை நீங்களே சரிபார்க்கவும். run()முறை அழைக்கப்பட வேண்டுமெனில் , அழைக்கவும் start(). மேலும் செல்வோம்.

Thread.sleep() முறை

தற்போதைய நூலின் செயல்பாட்டை சிறிது காலத்திற்கு இடைநிறுத்த, நாங்கள் sleep()முறையைப் பயன்படுத்துகிறோம். இந்த sleep()முறை பல மில்லி விநாடிகளை ஒரு வாதமாக எடுத்துக்கொள்கிறது, இது நூலை தூங்க வைக்கும் நேரத்தைக் குறிக்கிறது.

public class Main {

   public static void main(String[] args) throws InterruptedException {

       long start = System.currentTimeMillis();

       Thread.sleep(3000);

       System.out.println(" - How long did I sleep? \n - " + ((System.currentTimeMillis()-start)) / 1000 + " seconds");

   }
}

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

Thread.join() முறை

மற்றொரு த்ரெட் முடியும் வரை இந்த join()முறை நடப்பு நூலை செயல்படுத்துவதை நிறுத்தி வைக்கிறது. எங்களிடம் 2 நூல்கள் இருந்தால், t1மற்றும் t2, மற்றும் நாங்கள் எழுதுகிறோம்

t1.join()

அதன் வேலை முடியும் வரை t2தொடங்காது . t1நூல்களை செயல்படுத்தும் வரிசைக்கு உத்தரவாதம் அளிக்க இந்த join()முறையைப் பயன்படுத்தலாம். join()பின்வரும் எடுத்துக்காட்டில் இந்த முறை எவ்வாறு செயல்படுகிறது என்பதைக் கருத்தில் கொள்வோம் :

public class ThreadExample extends Thread {

   @Override
   public void run() {

       System.out.println("Thread started: " + getName());

       try {
           Thread.sleep(5000);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       System.out.println("Thread " + getName() + " is finished.");
   }
}


public class Main {

   public static void main(String[] args) throws InterruptedException {

       ThreadExample t1 = new ThreadExample();
       ThreadExample t2 = new ThreadExample();

       t1.start();


 /* The second thread (t2) will start running only after the first thread (t1)
       is finished (or an exception is thrown) */
       try {
           t1.join();
       } catch (InterruptedException e) {
           e.printStackTrace();
       }

       t2.start();

       // The main thread will continue running only after t1 and t2 have finished
       try {
           t1.join();
           t2.join();
       } catch (InterruptedException e) {
           e.printStackTrace();
       }

       System.out.println("All threads have finished. The program is finished.");

   }
}

நாங்கள் ஒரு எளிய ThreadExampleவகுப்பை உருவாக்கினோம். அதன் பணி என்னவென்றால், நூல் தொடங்கப்பட்ட செய்தியைக் காண்பிப்பது, 5 வினாடிகள் தூங்குவது, பின்னர் வேலை முடிந்தது என்று அறிக்கை செய்வது. கேக் துண்டு. முக்கிய தர்க்கம் வகுப்பில் உள்ளது Main. கருத்துகளைப் பார்க்கவும்: join()த்ரெட்களின் செயலாக்க வரிசையை வெற்றிகரமாக நிர்வகிக்க நாங்கள் முறையைப் பயன்படுத்துகிறோம். இந்த தலைப்பை நாங்கள் எவ்வாறு தொடங்கினோம் என்பதை நீங்கள் நினைவில் வைத்திருந்தால், செயல்படுத்தும் வரிசையை த்ரெட் ஷெட்யூலரால் கையாளப்படும். இது அதன் சொந்த விருப்பப்படி நூல்களை இயக்குகிறது: ஒவ்வொரு முறையும் வெவ்வேறு வழியில். நூல் t1முதலில் தொடங்கப்பட்டு முதலில் செயல்படுத்தப்படும், பின்னர் திt2நூல், அதன் பிறகுதான் நிரலின் முக்கிய இழை தொடரும். நகர்கிறது. உண்மையான நிரல்களில், ஒரு நூலை செயல்படுத்துவதில் குறுக்கீடு செய்ய வேண்டிய சூழ்நிலைகளை நீங்கள் அடிக்கடி காணலாம். எடுத்துக்காட்டாக, எங்கள் நூல் இயங்குகிறது, ஆனால் அது ஒரு குறிப்பிட்ட நிகழ்வு அல்லது நிபந்தனைக்காக காத்திருக்கிறது. அது ஏற்பட்டால், நூல் நின்றுவிடும். ஏதேனும் ஒரு முறை இருந்தால் அது அர்த்தமுள்ளதாக இருக்கும் stop(). ஆனால் அது அவ்வளவு எளிதல்ல. ஒரு காலத்தில், ஜாவா உண்மையில் ஒரு Thread.stop()முறையைக் கொண்டிருந்தது மற்றும் ஒரு நூலை குறுக்கிட அனுமதித்தது. ஆனால் பின்னர் அது ஜாவா நூலகத்திலிருந்து நீக்கப்பட்டது. நீங்கள் அதை Oracle ஆவணத்தில் காணலாம் மற்றும் அது நிறுத்தப்பட்டதாகக் குறிக்கப்பட்டிருப்பதைக் காணலாம். ஏன்? ஏனென்றால் அது வேறெதுவும் செய்யாமல் திரியை நிறுத்தியது. எடுத்துக்காட்டாக, த்ரெட் தரவுகளுடன் வேலை செய்து எதையாவது மாற்றிக் கொண்டிருக்கலாம். பின்னர் அதன் வேலையின் நடுவில் திடீரென முறைப்படி துண்டிக்கப்பட்டது stop(). சரியான பணிநிறுத்தம் இல்லாமல், அல்லது வளங்களை வெளியிடாமல், பிழை கையாளுதல் கூட இல்லை - இவை எதுவும் இல்லை. சற்று பெரிதுபடுத்த, stop()முறை அதன் வழியில் அனைத்தையும் அழித்தது. கம்ப்யூட்டரை அணைக்க அவுட்லெட்டில் இருந்து மின் கம்பியை இழுப்பது போல் இருந்தது. ஆம், நீங்கள் விரும்பிய முடிவைப் பெறலாம். ஆனால், இரண்டு வாரங்களுக்குப் பிறகு, கணினி அவ்வாறு நடத்துவதற்கு நன்றி சொல்லாது என்பது அனைவருக்கும் தெரியும். அதனால்தான் ஜாவாவில் குறுக்கீடு த்ரெட்களுக்கான லாஜிக் மாறி இப்போது ஒரு சிறப்பு interrupt()முறையைப் பயன்படுத்துகிறது.

Thread.interrupt() முறை

interrupt()முறை ஒரு நூலில் அழைக்கப்பட்டால் என்ன நடக்கும் ? 2 சாத்தியங்கள் உள்ளன:

1. பொருள் காத்திருக்கும் நிலையில் இருந்தால், எடுத்துக்காட்டாக, joinஅல்லது sleepமுறைகள் காரணமாக, காத்திருப்பு குறுக்கிடப்படும் மற்றும் நிரல் ஒரு InterruptedException.
2. நூல் செயல்படும் நிலையில் இருந்தால், interruptedபொருளின் மீது பூலியன் கொடி அமைக்கப்படும்.

ஆனால் இந்த கொடியின் மதிப்பை பொருளின் மீது சரிபார்த்து, சொந்தமாக வேலையை சரியாக முடிக்க வேண்டும்! அதனால்தான் Threadவகுப்பில் முறை உள்ளது boolean isInterrupted(). அடிப்படை பாடத்தில் ஒரு பாடத்தில் இருந்த கடிகார உதாரணத்திற்கு திரும்புவோம். வசதிக்காக, நாங்கள் அதை சிறிது எளிமைப்படுத்தியுள்ளோம்:

public class Clock extends Thread {

   public static void main(String[] args) throws InterruptedException {
       Clock clock = new Clock();
       clock.start();

       Thread.sleep(10000);
       clock.interrupt();
   }

   public void run() {
       Thread current = Thread.currentThread();

       while (!current.isInterrupted())
       {
           try {
               Thread.sleep(1000);
           } catch (InterruptedException e) {
               System.out.println("The thread was interrupted");
               break;
           }
           System.out.println("Tick");
       }
   }
}

இந்த வழக்கில், கடிகாரம் தொடங்கப்பட்டு ஒவ்வொரு நொடியும் டிக் செய்யத் தொடங்குகிறது. 10 வது வினாடியில், கடிகாரத்தின் நூலை குறுக்கிடுகிறோம். உங்களுக்கு ஏற்கனவே தெரியும், நாங்கள் குறுக்கிட முயற்சிக்கும் திரி காத்திருக்கும் நிலைகளில் ஒன்றில் இருந்தால், முடிவு ஒரு InterruptedException. இது சரிபார்க்கப்பட்ட விதிவிலக்காகும், எனவே நாம் எளிதாகப் பிடிக்கலாம் மற்றும் நிரலை முடிக்க எங்கள் தர்க்கத்தை இயக்கலாம். அதைத்தான் நாங்கள் செய்தோம். எங்கள் முடிவு இதோ: டிக் டிக் டிக் டிக் டிக் டிக் டிக் டிக் டிக் டிக் நூல் குறுக்கிடப்பட்டது இது Threadவகுப்பின் மிக முக்கியமான முறைகள் பற்றிய எங்கள் அறிமுகத்தை முடிக்கிறது. நல்ல அதிர்ஷ்டம்!