செயல்முறைகள் என்ன, அவற்றை உபுண்டுவில் எவ்வாறு நிர்வகிக்கலாம்

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

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

நாம் அனைவரும் அறிந்தபடி, உபுண்டு (குனு / லினக்ஸ்) ஒரு பல்பணி இயக்க முறைமை. இதன் பொருள் பல செயல்முறைகளை (பணிகளை) ஒரே நேரத்தில், அவற்றுக்கிடையே சிக்கல்கள் இல்லாமல் செயல்படுத்தும் திறன் கொண்டது.

ஆனால்… ஒரு செயல்முறை என்றால் என்ன?

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

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

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

நாம் அதை ஒரு எடுத்துக்காட்டுடன் காணலாம்:

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

gedit f_test

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

gedit f_test &

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

உபுண்டுவில் என்ன செயல்முறைகள் இயங்குகின்றன என்பதை நான் எவ்வாறு அறிந்து கொள்வது?

இயங்கும் செயல்முறைகளின் பட்டியலைக் காண, ஒரு முனையத்தைத் திறந்து இயக்கவும்:

ps -aux

பின்வருவனவற்றைப் போன்ற ஒரு வெளியீட்டைக் காண்போம்:

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

கூடுதலாக, உபுண்டு (மற்றும் அனைத்து குனு / லினக்ஸ் டிஸ்ட்ரோக்கள்) PID இன் அதிகபட்ச மதிப்பை நிர்ணயிக்கும் ஒரு கோப்பைக் கொண்டுள்ளன. இது வெளிப்படையாக தீர்மானிக்கிறது இயக்க அதிகபட்ச செயல்முறைகள். கோப்பு அழைக்கப்படுகிறது pid_max அது / proc / sys / kernel / அடைவுக்குள் இருக்கிறது. அதன் உள்ளடக்கத்தை விரைவாகப் பார்க்க விரும்பினால், இயக்கவும்:

cat / proc / sys / kernel / pid_max

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

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

ps -aux | grep ஜிம்ப்

நீங்கள் பார்க்க முடியும் என, என் விஷயத்தில் ஜிம்புடன் தொடர்புடைய 3 செயல்முறைகள் உள்ளன.

மேலும் ... ஒரு செயல்முறையை நான் எவ்வாறு கொல்ல முடியும்?

ஒரு செயல்முறையைக் கொல்வது என்பது முடிவுக்கு வருவது, செயல்முறை முடிவடைவதற்கு தொடர்புடைய சமிக்ஞையை அனுப்புதல். அவ்வாறு செய்வது கட்டளையைப் பயன்படுத்துவது போல எளிதானது கொல்ல. நாம் கொல்ல விரும்பும் செயல்முறையின் PID ஐ நாம் தெரிந்து கொள்ள வேண்டியது இதுதான். மேலே உள்ள எடுத்துக்காட்டில், 5649 ஐ அதன் பிஐடியாகக் கொண்ட ஜிம்ப் செயல்முறையை நான் கொல்ல விரும்புகிறேன் என்று சொல்லலாம். சரி, ஓடுங்கள்:

கொல்லுங்கள்

இப்போது நான் ஒரே நேரத்தில் எப்படி கொல்ல முடியும் ஒரு நிரலுடன் தொடர்புடைய அனைத்து செயல்முறைகளும்? மிகவும் எளிதானது. என் விஷயத்தில் நான் அனைத்து ஜிம்ப் செயல்முறைகளையும் கொல்ல விரும்பினால், நான் கட்டளையைப் பயன்படுத்தலாம் கொல்ல. பின்வரும் வழியில்:

பிகில் ஜிம்ப்

இது கொல்லும் அனைத்து ஜிம்ப் செயல்முறைகள், அதாவது, PID கள் 5649, 5719 மற்றும் 5782 உடன் செயல்முறைகள். எளிதானதா? ஒரு நிரல் உறைந்து, அதை எப்படி முடிப்பது என்று உங்களுக்குத் தெரியாவிட்டால், இப்போது உங்களுக்கு சாத்தியமான தீர்வு உள்ளது solution

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

அடுத்த முறை வரை