ஒன்றாகச் சிறந்தது: ஜாவா மற்றும் நூல் வகுப்பு. பகுதி I - மரணதண்டனையின் நூல்கள்

அறிமுகம்

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

class HelloWorldApp {
    public static void main(String[] args) {
        System.out.println("Hello, " + args[0]);
    }
}

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

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 0
        at HelloWorldApp.main(HelloWorldApp.java:3)

"முக்கிய" என்ற நூலில் விதிவிலக்கு (அதாவது பிழை) ஏற்பட்டது. எனவே, ஜாவாவில் நூல்கள் உள்ளதா? இங்குதான் நமது பயணம் தொடங்குகிறது.

ஜாவா மற்றும் நூல்கள்

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

class HelloWorldApp {
    public static void main(String[] args) {
		while (true) { 
			// Do nothing
		}
	}
}

இப்போது அதை மீண்டும் தொகுக்கலாம் javac. வசதிக்காக, எங்கள் ஜாவா குறியீட்டை தனி சாளரத்தில் இயக்குவோம். விண்டோஸில், இதை இப்படி செய்யலாம்: start java HelloWorldApp. ஜாவா நமக்குச் சொல்லும் தகவலைப் பார்க்க இப்போது jps பயன்பாட்டைப் பயன்படுத்துவோம் : முதல் எண் PID அல்லது செயல்முறை ஐடி. செயல்முறை என்றால் என்ன?

A process is a combination of code and data sharing a common virtual address space.

செயல்முறைகளுடன், வெவ்வேறு நிரல்கள் அவை இயங்கும்போது ஒருவருக்கொருவர் தனிமைப்படுத்தப்படுகின்றன: ஒவ்வொரு பயன்பாடும் மற்ற நிரல்களுடன் குறுக்கிடாமல் நினைவகத்தில் அதன் சொந்த பகுதியைப் பயன்படுத்துகிறது. மேலும் அறிய, இந்த டுடோரியலைப் படிக்க பரிந்துரைக்கிறேன்: செயல்முறைகள் மற்றும் நூல்கள் . ஒரு செயல்முறை ஒரு நூல் இல்லாமல் இருக்க முடியாது, எனவே ஒரு செயல்முறை இருந்தால், அது குறைந்தது ஒரு நூலையாவது கொண்டிருக்கும். ஆனால் ஜாவாவில் இது எப்படி வருகிறது? நாம் ஒரு ஜாவா நிரலைத் தொடங்கும்போது, ​​செயல்படுத்தல் முறையுடன் தொடங்குகிறது main. நாங்கள் நிரலுக்குள் நுழைவது போல் உள்ளது, எனவே இந்த சிறப்பு mainமுறை நுழைவு புள்ளி என்று அழைக்கப்படுகிறது. இந்த mainமுறை எப்போதும் "பொது நிலையான வெற்றிடமாக" இருக்க வேண்டும், இதனால் ஜாவா மெய்நிகர் இயந்திரம் (JVM) எங்கள் நிரலை இயக்கத் தொடங்கும். மேலும் தகவலுக்கு, ஜாவா பிரதான முறை ஏன் நிலையானது?. ஜாவா லாஞ்சர் (java.exe அல்லது javaw.exe) ஒரு எளிய சி பயன்பாடு என்று மாறிவிடும்: இது உண்மையில் JVM ஐ உள்ளடக்கிய பல்வேறு DLL களை ஏற்றுகிறது. ஜாவா லாஞ்சர் ஒரு குறிப்பிட்ட ஜாவா நேட்டிவ் இன்டர்ஃபேஸ் (JNI) அழைப்புகளை செய்கிறது. JNI என்பது ஜாவா மெய்நிகர் இயந்திரத்தின் உலகத்தை C++ உலகத்துடன் இணைப்பதற்கான ஒரு பொறிமுறையாகும். எனவே, துவக்கி என்பது JVM அல்ல, மாறாக அதை ஏற்றுவதற்கான ஒரு பொறிமுறையாகும். JVM ஐ தொடங்குவதற்கு சரியான கட்டளைகளை இயக்குவதற்கு இது தெரியும். தேவையான சூழலை அமைப்பதற்கு JNI அழைப்புகளை எவ்வாறு பயன்படுத்துவது என்பது தெரியும். இந்த சூழலை அமைப்பதில் முக்கிய நூலை உருவாக்குவது அடங்கும், இது "முக்கிய" என்று அழைக்கப்படுகிறது. ஜாவா செயல்பாட்டில் எந்த நூல்கள் உள்ளன என்பதை சிறப்பாக விளக்க, நாம் jvisualvm ஐப் பயன்படுத்துகிறோம்கருவி, இது JDK உடன் சேர்க்கப்பட்டுள்ளது. ஒரு செயல்முறையின் pid அறிந்து, அந்த செயல்முறையைப் பற்றிய தகவலை உடனடியாகக் காணலாம்: jvisualvm --openpid <process id> சுவாரஸ்யமாக, ஒவ்வொரு தொடருக்கும் அதன் சொந்த தனிப் பகுதி நினைவகத்தில் ஒதுக்கப்பட்டுள்ளது. இந்த நினைவக அமைப்பு அடுக்கு என்று அழைக்கப்படுகிறது. ஒரு அடுக்கு பிரேம்களைக் கொண்டுள்ளது. ஒரு சட்டமானது ஒரு முறையின் செயல்பாட்டைக் குறிக்கிறது (ஒரு முடிக்கப்படாத முறை அழைப்பு). ஒரு சட்டத்தை StackTraceElement ஆகவும் குறிப்பிடலாம் ( StackTraceElement க்கான Java API ஐப் பார்க்கவும் ). ஒவ்வொரு தொடருக்கும் ஒதுக்கப்பட்ட நினைவகம் பற்றிய கூடுதல் தகவல்களை இங்கே விவாதத்தில் காணலாம்: " ஜாவா (ஜேவிஎம்) ஒவ்வொரு தொடருக்கும் அடுக்கை எவ்வாறு ஒதுக்குகிறது ". நீங்கள் Java API ஐப் பார்த்து, "Thread" என்ற வார்த்தையைத் தேடினால், java.lang.Thread ஐக் காணலாம்.வர்க்கம். இது ஜாவாவில் ஒரு நூலைக் குறிக்கும் வகுப்பாகும், அதனுடன் நாம் வேலை செய்ய வேண்டும்.

java.lang.Thread

ஜாவாவில், ஒரு நூல் வகுப்பின் நிகழ்வால் குறிப்பிடப்படுகிறது java.lang.Thread. த்ரெட் வகுப்பின் நிகழ்வுகள் செயல்படுத்தும் நூல்கள் அல்ல என்பதை நீங்கள் உடனடியாக புரிந்து கொள்ள வேண்டும். இது JVM மற்றும் இயக்க முறைமையால் நிர்வகிக்கப்படும் குறைந்த-நிலை த்ரெட்களுக்கான ஒரு வகையான API ஆகும். ஜாவா லாஞ்சரைப் பயன்படுத்தி நாம் JVM ஐத் தொடங்கும்போது, ​​​​அது main"முதன்மை" என்றழைக்கப்படும் ஒரு நூலையும் மேலும் சில வீட்டு பராமரிப்பு நூல்களையும் உருவாக்குகிறது. த்ரெட் வகுப்பிற்கான JavaDoc இல் கூறப்பட்டுள்ளபடி: When a Java Virtual Machine starts up, there is usually a single non-daemon thread. 2 வகையான நூல்கள் உள்ளன: டீமான்கள் மற்றும் டீமான்கள் அல்லாதவர்கள். டீமான் நூல்கள் பின்னணியில் சில வேலைகளைச் செய்யும் பின்னணி (ஹவுஸ் கீப்பிங்) நூல்கள். "டெமான்" என்ற வார்த்தை மேக்ஸ்வெல்லின் பேயைக் குறிக்கிறது. இந்த விக்கிபீடியா கட்டுரையில் நீங்கள் மேலும் அறியலாம் . ஆவணத்தில் கூறப்பட்டுள்ளபடி, JVM நிரலை (செயல்முறை) தொடர்ந்து செயல்படுத்துகிறது:

• Runtime.exit () முறை அழைக்கப்படுகிறது
• அனைத்து டீமான் அல்லாத நூல்களும் தங்கள் வேலையை முடிக்கின்றன (பிழைகள் இல்லாமல் அல்லது எறியப்பட்ட விதிவிலக்குகளுடன்)

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

public static void main(String[] args) {
	Thread currentThread = Thread.currentThread();
	ThreadGroup threadGroup = currentThread.getThreadGroup();
	System.out.println("Thread: " + currentThread.getName());
	System.out.println("Thread Group: " + threadGroup.getName());
	System.out.println("Parent Group: " + threadGroup.getParent().getName());
}

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

public static void main(String[] args) {
	Thread th = Thread.currentThread();
	th.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
		@Override
		public void uncaughtException(Thread t, Throwable e) {
			System.out.println("An error occurred: " + e.getMessage());
		}
	});
    System.out.println(2/0);
}

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

ஒரு நூலை உருவாக்குதல்

ஆவணத்தில் கூறப்பட்டுள்ளபடி, ஒரு நூலை உருவாக்க 2 வழிகள் உள்ளன. உங்கள் சொந்த துணை வகுப்பை உருவாக்குவதே முதல் வழி. உதாரணத்திற்கு:

public class HelloWorld{
    public static class MyThread extends Thread {
        @Override
        public void run() {
            System.out.println("Hello, World!");  
        }
    }
    
    public static void main(String[] args) {
        Thread thread = new MyThread();
        thread.start();
    }
}

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

public void run() {
	if (target != null) {
		target.run();
	}
}

நூல் வகுப்பின் நிகழ்வை உருவாக்கும் போது நாம் அனுப்பக்கூடிய targetசில இங்கே உள்ளது. java.lang.Runnableஇதன் பொருள் நாம் இதைச் செய்யலாம்:

public class HelloWorld{
    public static void main(String[] args) {
        Runnable task = new Runnable() {
            public void run() {
                System.out.println("Hello, World!");
            } 
        };
        Thread thread = new Thread(task);
        thread.start();
    }
}

Runnableஜாவா 1.8 முதல் செயல்பாட்டு இடைமுகமாகவும் உள்ளது. இது ஒரு நூலின் பணிக்கு இன்னும் அழகான குறியீட்டை எழுதுவதை சாத்தியமாக்குகிறது:

public static void main(String[] args) {
	Runnable task = () -> { 
		System.out.println("Hello, World!");
	};
	Thread thread = new Thread(task);
	thread.start();
}

முடிவுரை

இந்த விவாதம் நூல் என்றால் என்ன, நூல்கள் எவ்வாறு உருவாகின்றன, நூல்கள் மூலம் என்ன அடிப்படை செயல்பாடுகளை செய்யலாம் என்பதை தெளிவுபடுத்தும் என நம்புகிறேன். அடுத்த பகுதியில் , த்ரெட்கள் எப்படி ஒன்றோடு ஒன்று தொடர்பு கொள்கின்றன என்பதைப் புரிந்துகொள்ளவும், நூல் வாழ்க்கைச் சுழற்சியை ஆராயவும் முயற்சிப்போம். ஒன்றாகச் சிறந்தது: ஜாவா மற்றும் நூல் வகுப்பு. பகுதி II - ஒன்றாக ஒத்திசைத்தல் சிறந்தது: ஜாவா மற்றும் நூல் வகுப்பு. பகுதி III — ஒன்றாகச் செயல்படுவது சிறந்தது: ஜாவா மற்றும் த்ரெட் வகுப்பு. பகுதி IV - அழைக்கக்கூடிய, எதிர்காலம் மற்றும் நண்பர்கள் ஒன்றாக இருப்பது சிறந்தது: ஜாவா மற்றும் த்ரெட் வகுப்பு. பகுதி V - எக்ஸிகியூட்டர், த்ரெட்பூல், ஃபோர்க்/சேர் பெட்டர் பெட்டர்: ஜாவா மற்றும் த்ரெட் கிளாஸ். பகுதி VI - நெருப்பு!