ஜாவா நினைவக மாதிரி

ஜாவா மெமரி மாடலுக்கான அறிமுகம்

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

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

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

எனவே, நினைவக வழிமுறை மறுவடிவமைப்பு செய்யப்பட்டுள்ளது. 2005 ஆம் ஆண்டில், ஜாவா 5 இன் வெளியீட்டில், ஒரு புதிய அணுகுமுறை வழங்கப்பட்டது, இது ஜாவா 14 வெளியீட்டில் மேலும் மேம்படுத்தப்பட்டது.

புதிய மாடல் மூன்று விதிகளை அடிப்படையாகக் கொண்டது:

விதி #1 : ஒற்றை-திரிக்கப்பட்ட நிரல்கள் போலி-வரிசையாக இயங்குகின்றன. இதன் பொருள்: உண்மையில், செயலி ஒரு கடிகாரத்திற்கு பல செயல்பாடுகளைச் செய்ய முடியும், அதே நேரத்தில் அவற்றின் வரிசையை மாற்றுகிறது, இருப்பினும், அனைத்து தரவு சார்புகளும் இருக்கும், எனவே நடத்தை வரிசைமுறையிலிருந்து வேறுபடுவதில்லை.

விதி எண் 2 : எங்கும் இல்லாத மதிப்புகள் இல்லை. ஏதேனும் மாறியைப் படித்தால் (நிலை மாறாத நீளம் மற்றும் இரட்டிப்பைத் தவிர, இந்த விதி இயங்காது) இயல்புநிலை மதிப்பை (பூஜ்ஜியம்) அல்லது வேறு கட்டளையால் எழுதப்பட்ட ஒன்றை வழங்கும்.

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

முன்பு நடக்கும்

லெஸ்லி லம்போர்ட் முன்பு ஹேப்பன்ஸ் என்ற கருத்தை கொண்டு வந்தார் . இது அணு கட்டளைகளுக்கு (++ மற்றும் -- அணு அல்ல) இடையே அறிமுகப்படுத்தப்பட்ட ஒரு கண்டிப்பான பகுதி வரிசை உறவு மற்றும் "உடல் ரீதியாக முன்" என்று அர்த்தம் இல்லை.

முதல் அணி செய்த மாற்றங்களை இரண்டாவது அணி "தெரியும்" என்று அது கூறுகிறது.

எடுத்துக்காட்டாக, அத்தகைய செயல்பாடுகளுக்கு ஒன்று மற்றொன்றுக்கு முன் செயல்படுத்தப்படுகிறது:

ஒத்திசைவு மற்றும் மானிட்டர்கள்:

• மானிட்டரைப் பிடிக்கும் ( பூட்டு முறை , ஒத்திசைக்கப்பட்ட தொடக்கம்) மற்றும் அதற்குப் பிறகு அதே நூலில் என்ன நடந்தாலும்.
• மானிட்டரின் ரிட்டர்ன் (முறை அன்லாக் , ஒத்திசைவின் முடிவு) மற்றும் அதற்கு முன் அதே திரியில் என்ன நடந்தாலும்.
• மானிட்டரைத் திருப்பி, மற்றொரு நூல் மூலம் அதைப் பிடிக்கவும்.

எழுதுதல் மற்றும் படித்தல்:

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

பொருள் பராமரிப்பு:

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

ஸ்ட்ரீம் சேவை:

• நூலில் உள்ள எந்தக் குறியீட்டையும் தொடங்குதல்.
• நூல் மற்றும் நூலில் உள்ள எந்தக் குறியீடும் தொடர்பான பூஜ்ஜிய மாறிகள்.
• இழையில் குறியீடு மற்றும் ஜாயின்() ; நூலில் உள்ள குறியீடு மற்றும் isAlive() == false .
• நூலை குறுக்கிட்டு () அது நிறுத்தப்பட்டதைக் கண்டறியவும்.

வேலை நுணுக்கங்களுக்கு முன் நடக்கும்

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

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

public class Keeper {
    private Data data = null;

    public Data getData() {
        synchronized(this) {
            if(data == null) {
                data = new Data();
            }
        }

        return data;
    }
}

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

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

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

public class Keeper {
    private volatile Data data = null;

    public Data getData() {
        if(data == null) {
            synchronized(this) {
                if(data == null) {
                    data = new Data();
                }
            }
        }
        return data;
    }
}

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