ஜாவாவில் மல்டித்ரெடிங்

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

மல்டித்ரெடிங் மூலம் சிக்கல்கள் தீர்க்கப்படுகின்றன

மல்டித்ரெடிங் உண்மையில் இரண்டு முக்கிய நோக்கங்களை அடைய கண்டுபிடிக்கப்பட்டது:

1. ஒரே நேரத்தில் பல விஷயங்களைச் செய்யுங்கள்.

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

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

   சரி, இரண்டு நிமிடங்கள் காத்திருப்போம் என்று நினைக்கிறேன்!

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

2. கணக்கீடுகளை விரைவாகச் செய்யுங்கள்.

   இங்கே எல்லாம் மிகவும் எளிமையானது. நமது செயலியில் பல கோர்கள் இருந்தால், மற்றும் இன்று பெரும்பாலான செயலிகள் செய்தால், பல கோர்கள் நமது பணிகளின் பட்டியலை இணையாக கையாள முடியும். வெளிப்படையாக, நாம் 1000 பணிகளைச் செய்ய வேண்டும் மற்றும் ஒவ்வொன்றும் ஒரு வினாடி எடுத்தால், ஒரு கோர் 1000 வினாடிகளில் பட்டியலை முடிக்க முடியும், இரண்டு கோர்கள் 500 வினாடிகளில், மூன்று 333 வினாடிகளுக்கு சற்று அதிகமாகும்.

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

public class MyFirstThread extends Thread {

   @Override
   public void run() {
       System.out.println("I'm Thread! My name is " + getName());
   }
}

த்ரெட்களை உருவாக்க மற்றும் இயக்க, நாம் ஒரு வகுப்பை உருவாக்க வேண்டும், அதை java.lang ஐப் பெற வேண்டும் . நூல் வகுப்பு, அதன் ரன்() முறையை மேலெழுதவும் . அந்த கடைசி தேவை மிகவும் முக்கியமானது. ரன்() முறையில் தான் நமது த்ரெட்டை இயக்குவதற்கான தர்க்கத்தை வரையறுக்கிறோம். இப்போது, ​​நாம் MyFirstThread இன் நிகழ்வை உருவாக்கி இயக்கினால் , ரன்() முறை ஒரு பெயருடன் ஒரு வரியைக் காண்பிக்கும்: getName() முறை தானாக ஒதுக்கப்படும் நூலின் 'சிஸ்டம்' பெயரைக் காட்டுகிறது. ஆனால் நாம் ஏன் தற்காலிகமாக பேசுகிறோம்? ஒன்றை உருவாக்கி கண்டுபிடிப்போம்!

public class Main {

   public static void main(String[] args) {

       for (int i = 0; i < 10; i++) {

           MyFirstThread thread = new MyFirstThread();
           thread.start();
       }
   }
}

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

மல்டித்ரெடிங்கால் உருவாக்கப்பட்ட சிக்கல்கள்

புத்தகங்களுடனான எங்கள் எடுத்துக்காட்டில், மல்டித்ரெடிங் மிக முக்கியமான பணிகளைத் தீர்க்கிறது மற்றும் எங்கள் நிரல்களை விரைவாகச் செய்ய முடியும் என்பதை நீங்கள் பார்த்தீர்கள். பெரும்பாலும் பல மடங்கு வேகமாக. ஆனால் மல்டித்ரெடிங் ஒரு கடினமான தலைப்பு என்று கருதப்படுகிறது. உண்மையில், தவறாகப் பயன்படுத்தினால், அது அவற்றைத் தீர்ப்பதற்குப் பதிலாக சிக்கல்களை உருவாக்குகிறது. 'சிக்கல்களை உருவாக்குகிறது' என்று நான் கூறும்போது, ​​சில சுருக்க அர்த்தத்தில் நான் சொல்லவில்லை. மல்டித்ரெடிங் உருவாக்கக்கூடிய இரண்டு குறிப்பிட்ட சிக்கல்கள் உள்ளன: முட்டுக்கட்டை மற்றும் ரேஸ் நிலைமைகள். டெட்லாக் என்பது பல இழைகள் ஒன்றோடொன்று வைத்திருக்கும் ஆதாரங்களுக்காகக் காத்திருக்கும் ஒரு சூழ்நிலையாகும், மேலும் அவை எதுவும் தொடர்ந்து இயங்க முடியாது. அடுத்த பாடங்களில் அதைப் பற்றி மேலும் பேசுவோம். பின்வரும் உதாரணம் இப்போதைக்கு போதுமானதாக இருக்கும்: Thread-1 சில பொருள்-1 உடன் தொடர்பு கொள்கிறது என்றும், Thread-2 Object-2 உடன் தொடர்பு கொள்கிறது என்றும் கற்பனை செய்து பாருங்கள். மேலும், நிரல் இவ்வாறு எழுதப்பட்டுள்ளது:

1. நூல்-2 பொருள்-2 உடன் தொடர்புகொள்வதை நிறுத்திவிட்டு பொருள்-1 க்கு மாறியவுடன் நூல்-1 பொருள்-1 உடன் தொடர்புகொள்வதை நிறுத்திவிட்டு பொருள்-2 க்கு மாறுகிறது.
2. நூல்-1 பொருள்-1 உடன் தொடர்புகொள்வதை நிறுத்திவிட்டு பொருள்-2 க்கு மாறியவுடன் நூல்-2 பொருள்-2 உடன் தொடர்புகொள்வதை நிறுத்துகிறது மற்றும் பொருள்-1 க்கு மாறுகிறது.

மல்டித்ரெடிங் பற்றிய ஆழமான புரிதல் இல்லாவிட்டாலும், எதுவும் நடக்காது என்பதை நீங்கள் எளிதாகக் காணலாம். இழைகள் ஒருபோதும் இடங்களை மாற்றாது மற்றும் எப்போதும் ஒருவருக்கொருவர் காத்திருக்கும். பிழை வெளிப்படையாகத் தெரிகிறது, ஆனால் உண்மையில் அது இல்லை. நிரலில் இதை எளிதாக செய்யலாம். முட்டுக்கட்டை ஏற்படுத்தும் குறியீட்டின் உதாரணங்களை அடுத்தடுத்த பாடங்களில் பரிசீலிப்போம். சொல்லப்போனால், Quora என்ன முட்டுக்கட்டை என்பதை விளக்கும் ஒரு சிறந்த நிஜ வாழ்க்கை உதாரணத்தைக் கொண்டுள்ளதுஇருக்கிறது. 'இந்தியாவின் சில மாநிலங்களில், நீங்கள் பதிவு செய்யப்பட்ட விவசாயியாக இல்லாவிட்டால், அவர்கள் விவசாய நிலத்தை உங்களுக்கு விற்க மாட்டார்கள். இருப்பினும், உங்களுக்கு சொந்தமாக விவசாய நிலம் இல்லையென்றால் அவர்கள் உங்களை விவசாயி என்று பதிவு செய்ய மாட்டார்கள். நன்று! நாம் என்ன சொல்ல முடியும்?! :) இப்போது இன நிலைமைகள் பற்றி பேசலாம். ரேஸ் நிபந்தனை என்பது மல்டித்ரெட் சிஸ்டம் அல்லது அப்ளிகேஷனில் ஏற்படும் வடிவமைப்புப் பிழையாகும், இதில் கணினி அல்லது பயன்பாட்டின் செயல்பாடு குறியீட்டின் பகுதிகள் செயல்படுத்தப்படும் வரிசையைப் பொறுத்தது. நினைவில் கொள்ளுங்கள், நாங்கள் இழைகளைத் தொடங்கிய உதாரணம்:

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();
       }
   }
}

உணவை சமைக்கும் ரோபோவை இயக்குவதற்கு நிரல் பொறுப்பு என்று இப்போது கற்பனை செய்து பாருங்கள்! நூல்-0 குளிர்சாதன பெட்டியில் இருந்து முட்டைகளை பெறுகிறது. நூல்-1 அடுப்பை இயக்குகிறது. நூல்-2 ஒரு பாத்திரத்தை எடுத்து அடுப்பில் வைக்கிறது. நூல்-3 அடுப்பை பற்றவைக்கிறது. நூல்-4 கடாயில் எண்ணெய் ஊற்றுகிறது. நூல்-5 முட்டைகளை உடைத்து வாணலியில் ஊற்றுகிறது. நூல்-6 முட்டை ஓடுகளை குப்பைத் தொட்டியில் வீசுகிறது. நூல்-7 பர்னரில் இருந்து சமைத்த முட்டைகளை நீக்குகிறது. நூல்-8 சமைத்த முட்டைகளை ஒரு தட்டில் வைக்கிறது. நூல்-9 பாத்திரங்களைக் கழுவுகிறது. எங்கள் நிரலின் முடிவுகளைப் பார்க்கவும்: Thread செயல்படுத்தப்பட்டது: Thread-0 Thread செயல்படுத்தப்பட்டது: Thread-2 Thread இயக்கப்பட்டது செயல்படுத்தப்பட்டது: நூல்-7 நூல் செயல்படுத்தப்பட்டது: நூல்-3 இது காமெடி வாடிக்கையா? :) மற்றும் அனைத்து ஏனெனில் எங்கள் நிரல் வேலை நூல்கள் செயல்படுத்தும் வரிசையை சார்ந்துள்ளது. தேவையான வரிசையின் சிறிதளவு மீறல் கொடுக்கப்பட்டால், எங்கள் சமையலறை நரகமாக மாறும், மேலும் ஒரு பைத்தியக்கார ரோபோ அதைச் சுற்றியுள்ள அனைத்தையும் அழிக்கிறது. மல்டித்ரெட் புரோகிராமிங்கிலும் இது ஒரு பொதுவான பிரச்சனை. நீங்கள் அதைப் பற்றி ஒன்றுக்கு மேற்பட்ட முறை கேள்விப்படுவீர்கள். இந்த பாடத்தை முடிக்கையில், மல்டித்ரெடிங் பற்றிய ஒரு புத்தகத்தை பரிந்துரைக்க விரும்புகிறேன். 'Java Concurrency in Practice' 2006 இல் எழுதப்பட்டது, ஆனால் அதன் பொருத்தத்தை இழக்கவில்லை. இது மல்டித்ரெட் ஜாவா புரோகிராமிங்கிற்கு அர்ப்பணிக்கப்பட்டுள்ளது - அடிப்படைகள் முதல் பொதுவான தவறுகள் மற்றும் எதிர் வடிவங்கள் வரை. நீங்கள் ஒரு நாள் மல்டித்ரெடிங் குருவாக மாற முடிவு செய்தால், இந்த புத்தகம் அவசியம் படிக்க வேண்டும். அடுத்த பாடங்களில் சந்திப்போம்! :)