பணிகள் மற்றும் செயல்முறைகள்

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

/home/larry# ps PID TT STAT TIME COMMAND 24 3 S 0:03 (bash) 161 3 R 0:00 ps /home/larry#

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

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

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

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

முன்புறம் மற்றும் பின்னணி பயன்முறை

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

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

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

இரண்டு சமிக்ஞைகள் - எண் 9 ( கொல்லுங்கள்) மற்றும் 19 ( நிறுத்து) - எப்போதும் கணினியால் செயலாக்கப்படும். செயல்முறையை நிச்சயமாகக் கொல்ல அவற்றில் முதலாவது தேவை (எனவே பெயர்). சிக்னல் நிறுத்து இடைநிறுத்துகிறது செயல்முறை: இந்த நிலையில், செயல்முறை அட்டவணையில் இருந்து செயல்முறை அகற்றப்படவில்லை, ஆனால் அது சமிக்ஞை 18 ஐப் பெறும் வரை செயல்படுத்தப்படாது ( தொடர்) - அதன் பிறகு அது தொடர்ந்து வேலை செய்யும். லினக்ஸ் கட்டளை ஷெல்லில், சிக்னல் நிறுத்துதப்பிக்கும் வரிசையைப் பயன்படுத்தி செயலில் உள்ள செயல்முறைக்கு அனுப்ப முடியும் Ctrl -Z .

சிக்னல் எண் 15 ( கால) வேலையை குறுக்கிட உதவுகிறது. மணிக்கு தடங்கல்(குறுக்கீடு) வேலை செயல்முறை இறக்கிறது. வேலைகள் பொதுவாக தப்பிக்கும் வரிசையால் குறுக்கிடப்படுகின்றன Ctrl -சி. தடைபட்ட வேலையை மீட்டெடுக்க வழி இல்லை. சில நிரல்கள் சிக்னலை இடைமறிக்கின்றன என்பதையும் நீங்கள் அறிந்திருக்க வேண்டும் கால(ஹேண்ட்லரைப் பயன்படுத்தி), அதனால் ஒரு முக்கிய கலவையை அழுத்தவும் Ctrl -சி(o) செயல்முறையை உடனடியாக நிறுத்த முடியாது. நிரல் முடிவடைவதற்கு முன்பு அதன் வேலையின் தடயங்களை அழிக்கும் வகையில் இது செய்யப்படுகிறது. நடைமுறையில், சில திட்டங்களை இந்த வழியில் குறுக்கிட முடியாது.

பின்னணிக்கு மாற்றுதல் மற்றும் வேலைகளை அழித்தல்

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

/home/larry# yes y y y y

அத்தகைய வரிகளின் வரிசை காலவரையின்றி தொடரும். குறுக்கீடு சமிக்ஞையை அனுப்புவதன் மூலம் இந்த செயல்முறையை நீங்கள் அழிக்கலாம், அதாவது அழுத்துவதன் மூலம் Ctrl -சி. இப்போது விஷயங்களை வித்தியாசமாக செய்வோம். இந்த முடிவற்ற வரிசை திரையில் காட்டப்படுவதைத் தடுக்க, ஆம் கட்டளையின் நிலையான வெளியீட்டை /dev/null க்கு திருப்பி விடுவோம். உங்களுக்குத் தெரிந்தபடி, /dev/null சாதனம் ஒரு "கருந்துளையாக" செயல்படுகிறது: இந்தச் சாதனத்திற்கு அனுப்பப்பட்ட எல்லாத் தரவும் தொலைந்துவிடும். இந்த சாதனத்தைப் பயன்படுத்தி, சில நிரல்களிலிருந்து அதிகப்படியான வெளியீட்டை அகற்றுவது மிகவும் வசதியானது.

/home/larry# ஆம் > /dev/null

இப்போது திரையில் எதுவும் காட்டப்படவில்லை. இருப்பினும், ஷெல் ப்ராம்ப்ட் திரும்பப் பெறப்படவில்லை. ஏனென்றால், ஆம் கட்டளை இன்னும் இயங்குகிறது மற்றும் அதன் செய்திகளை y க்கு /dev/null க்கு அனுப்புகிறது. குறுக்கீடு சமிக்ஞையை அனுப்புவதன் மூலமும் இந்த பணியை அழிக்கலாம்.

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

ஒரு செயல்முறையை பின்னணியில் வைப்பதற்கான ஒரு வழி & கட்டளையின் முடிவில் இணைப்பதாகும். உதாரணமாக:

/home/larry# ஆம் > /dev/null & + 164 /home/larry#

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

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

/home/larry# jobs + ஓடுகிறது ஆம் >/dev/null & /home/larry#

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

செயல்முறைக்கு ஒரு சமிக்ஞையை அனுப்புவதற்காக (பெரும்பாலும் தேவை உள்ளது குறுக்கீடுவேலை வேலை) பயன்பாடு பயன்படுத்தப்படுகிறது கொல்ல. இந்த கட்டளை ஒரு வேலை எண் அல்லது PID ஒரு வாதமாக கொடுக்கப்பட்டுள்ளது. ஒரு விருப்ப அளவுரு என்பது செயல்முறைக்கு அனுப்பப்பட வேண்டிய சமிக்ஞையின் எண்ணிக்கை. முன்னிருப்பாக சிக்னல் அனுப்பப்படும் கால. மேலே உள்ள வழக்கில், வேலை எண் 1, எனவே கட்டளை கொல்ல% 1வேலையில் இடையூறு ஏற்படும். ஒரு வேலையை அதன் எண்ணால் (அதன் PID ஐ விட) அணுகும் போது, ​​அந்த எண்ணுக்கு முன்னால் கட்டளை வரியில் ஒரு சதவீத குறியீடு ("%") இருக்க வேண்டும்.

இப்போது கட்டளையை உள்ளிடுவோம் வேலைகள்முந்தைய செயலின் முடிவை மீண்டும் சரிபார்க்க:

/home/larry# jobs நிறுத்தப்பட்டது ஆம் >/dev/null

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

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

வேலைகளை இடைநிறுத்துதல் மற்றும் மீண்டும் தொடங்குதல்

முன்பு செய்தது போல், முன்புறத்தில் yes கட்டளையுடன் செயல்முறையைத் தொடங்குவோம்:

/home/larry# ஆம் > /dev/null

முன்பு போலவே, செயல்முறை முன்புறத்தில் இயங்குவதால், ஷெல் ப்ராம்ட் திரைக்கு திரும்பாது.

இப்போது, ​​ஒரு முக்கிய கலவையுடன் பணியை குறுக்கிடுவதற்கு பதிலாக Ctrl -சி, பணி சாத்தியம் இடைநீக்கம்(சஸ்பெண்ட், அதாவது - இடைநிறுத்தம் செய்ய), அவருக்கு ஒரு சமிக்ஞையை அனுப்புகிறது நிறுத்து. ஒரு பணியை இடைநிறுத்த, நீங்கள் பொருத்தமான விசை கலவையை அழுத்த வேண்டும், பொதுவாக இது Ctrl -Z .

/home/larry# ஆம் > /dev/null Ctrl -Z+ நிறுத்தப்பட்டது ஆம் >/dev/null /home/larry#

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

முன்புறத்தில் இயங்கும் வேலையை மீண்டும் தொடங்க, நீங்கள் கட்டளையைப் பயன்படுத்தலாம் fg(முன்புறம் - முன்புறம் என்ற வார்த்தையிலிருந்து).

/home/larry# fg ஆம் >/dev/null

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

/home/larry# bg + yes $>$/dev/null & /home/larry#

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

பின்னணியில் இயங்கும் பணியை இடைநிறுத்த, விசைப்பலகை குறுக்குவழியைப் பயன்படுத்த முடியாது Ctrl -Z. ஒரு வேலையை இடைநிறுத்துவதற்கு முன், அதை கட்டளையுடன் முன்னோக்கி கொண்டு வர வேண்டும் fgபின்னர் மட்டுமே நிறுத்துங்கள். இவ்வாறு, கட்டளை fgஇடைநிறுத்தப்பட்ட வேலைகள் அல்லது பின்னணியில் இயங்கும் வேலைக்குப் பயன்படுத்தலாம்.

பின்னணி வேலைகளுக்கும் இடைநிறுத்தப்பட்ட வேலைகளுக்கும் பெரிய வித்தியாசம் உள்ளது. இடைநிறுத்தப்பட்ட பணி வேலை செய்யாது - அதற்கு பணம் செலவழிக்கப்படவில்லை கணினி சக்திசெயலி. இந்த வேலை எந்த செயலையும் செய்யாது. இடைநிறுத்தப்பட்ட பணி ஒரு குறிப்பிட்ட அளவு கணினி ரேம் ஆக்கிரமித்துள்ளது; சிறிது நேரம் கழித்து, நினைவகத்தின் இந்த பகுதியை கர்னல் பம்ப் செய்யும் HDD « மீண்டும் மீண்டும்" இதற்கு நேர்மாறாக, பின்னணி வேலை இயங்குகிறது, நினைவகத்தைப் பயன்படுத்துகிறது மற்றும் நீங்கள் செய்ய விரும்பும் சில விஷயங்களைச் செய்கிறது, ஆனால் நீங்கள் அதே நேரத்தில் மற்ற நிரல்களில் வேலை செய்யலாம்.

பின்னணியில் இயங்கும் வேலைகள் திரையில் சில உரைகளைக் காட்ட முயற்சிக்கலாம். இதனால் மற்ற பணிகளில் இடையூறு ஏற்படும்.

/வீடு/லாரி# ஆம் &

இங்கே நிலையான வெளியீடு /dev/null சாதனத்திற்கு திருப்பிவிடப்படவில்லை, எனவே y எழுத்துகளின் முடிவில்லா ஸ்ட்ரீம் திரையில் அச்சிடப்படும். விசை சேர்க்கை என்பதால் இந்த நூலை நிறுத்த முடியாது Ctrl -சிபின்னணியில் வேலைகளை பாதிக்காது. இந்த வெளியீட்டை நிறுத்த, நீங்கள் கட்டளையைப் பயன்படுத்த வேண்டும் fg, இது பணியை முன்னோக்கி கொண்டு வந்து, பின்னர் ஒரு முக்கிய கலவையுடன் பணியை அழிக்கும் Ctrl -சி .

இன்னும் ஒரு கருத்தைச் சொல்வோம். பொதுவாக அணியால் fgமற்றும் அணி bgசமீபத்தில் இடைநிறுத்தப்பட்ட அந்த வேலைகளை பாதிக்கும் (நீங்கள் கட்டளையை உள்ளிடினால், இந்த வேலைகள் வேலை எண்ணுக்கு அடுத்ததாக + சின்னத்துடன் குறிக்கப்படும் வேலைகள்) ஒன்று அல்லது அதற்கு மேற்பட்ட வேலைகள் ஒரே நேரத்தில் இயங்கினால், கட்டளைகளை வாதங்களாகக் குறிப்பிடுவதன் மூலம் வேலைகளை முன் அல்லது பின்னணியில் வைக்கலாம். fgஅல்லது கட்டளைகள் bgஅவர்களின் அடையாள எண் (வேலை ஐடி). உதாரணமாக, கட்டளை fg% 2வேலை எண் 2 ஐ முன் மற்றும் கட்டளைக்கு வைக்கிறது bg% 3வேலை எண் 3 ஐ பின்னணியில் வைக்கிறது. கட்டளை வாதங்களாக PIDகளைப் பயன்படுத்தவும் fgமற்றும் bgஅது தடைசெய்யப்பட்டுள்ளது.

மேலும், ஒரு வேலையை முன்னணியில் கொண்டு வர, அதன் எண்ணை நீங்கள் குறிப்பிடலாம். ஆம், குழு %2 கட்டளைக்கு சமமாக இருக்கும் fg% 2 .

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

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

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

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

இந்த கட்டளையை உள்ளிட்ட பிறகு, செயல்முறை தொடரும், ஆனால் பின்னணியில். பின்னணியில் இயங்கும் அனைத்து செயல்முறைகளையும் பார்க்க, நீங்கள் கட்டளையை உள்ளிடலாம்

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

பின்னணியில் காப்பகத்தைத் திறக்கிறது

$ tar -czf home.tar.gz .

கிளிக் செய்யவும் Cntr+Z, பின்னர் கட்டளைகளை உள்ளிடவும்

$bg$வேலைகள்

இரண்டாவது வழி, கட்டளையின் முடிவில் & சேர்ப்பது, இது பின்னணியில் கட்டளையை இயக்க கணினிக்கு சொல்லும்.

$ tar -czf home.tar.gz . &$வேலைகள்

இந்த முறையானது செயல்முறைகளை பின்னணியில் இயக்க அனுமதிக்கிறது, இருப்பினும், STDIN, STDOUT, STDERRஇன்னும் முனையத்துடன் இணைக்கப்பட்டுள்ளன. இப்போது டெர்மினல் மூடப்பட்டாலும் செயல்முறை இயங்குவதை உறுதி செய்வோம்.

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

$ sudo rsync டெம்ப்ளேட்கள்/* /var/www/html/ & $ jobs $ disown -h %1 $ வேலைகள்

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

$ nohup tar -czf iso.tar.gz டெம்ப்ளேட்கள்/* & $ வேலைகள்

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

$பயர்பாக்ஸ்/dev/null &

IN லினக்ஸ் அமைப்பு(மற்றும் கிட்டத்தட்ட அனைத்து யூனிக்ஸ் கணினிகளிலும்) /dev/null என்பது ஒரு சிறப்பு சாதனக் கோப்பு, இது "பூஜ்ய சாதனம்" என்றும் அழைக்கப்படுகிறது. பதிவுசெய்யப்பட்ட தகவலின் அளவைப் பொருட்படுத்தாமல் அதற்கு எழுதுவது வெற்றிகரமாக மேற்கொள்ளப்படுகிறது; அதிலிருந்து படிப்பது கோப்பின் முடிவைப் படிப்பதற்கு சமம் (EOF).

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

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

லினக்ஸ் சிக்னல்கள்

லினக்ஸில், சிஸ்டம் அல்லது அப்ளிகேஷன்களால் உருவாக்கப்படும் மூன்று டஜன் சிக்னல்கள் உள்ளன. ஸ்கிரிப்ட்களை உருவாக்கும் போது மிகவும் பொதுவாகப் பயன்படுத்தப்படும் ஒரு பட்டியல் இங்கே உள்ளது கட்டளை வரி.

சிக்னல் குறியீடு	பெயர்	விளக்கம்
1	SIGHUP	முனையத்தை மூடுகிறது
2	SIGINT	டெர்மினலில் (CTRL + C) பயனரால் செயல்முறையை நிறுத்துவதற்கான சமிக்ஞை
3	SIGQUIT	மெமரி டம்ப் மூலம் டெர்மினலில் (CTRL + \) பயனர் ஒரு செயல்முறையை நிறுத்துவதற்கான சமிக்ஞை
9	SIGKILL	செயல்முறையின் நிபந்தனையற்ற முடிவு
15	SIGTERM	செயல்முறை நிறுத்த கோரிக்கை சமிக்ஞை
17	SIGSTOP	ஒரு செயல்முறையை இடைநிறுத்தவும் ஆனால் நிறுத்தப்படவும் கட்டாயப்படுத்துகிறது
18	SIGTSTP	முனையத்திலிருந்து (CTRL+Z) ஒரு செயல்முறையை இடைநிறுத்துகிறது, ஆனால் நிறுத்தப்படவில்லை
19	SIGCONT	முன்பு நிறுத்தப்பட்ட செயல்முறையைத் தொடரவும்

நீங்கள் முனையத்தை மூடும்போது பாஷ் ஷெல் SIGHUP சமிக்ஞையைப் பெற்றால், அது வெளியேறும். வெளியேறும் முன், இயங்கும் ஸ்கிரிப்டுகள் உட்பட, அதில் இயங்கும் அனைத்து செயல்முறைகளுக்கும் SIGHUP சமிக்ஞையை அனுப்புகிறது.

SIGINT சமிக்ஞை செயல்பாட்டை தற்காலிகமாக நிறுத்துகிறது. லினக்ஸ் கர்னல் ஷெல்லுக்கு செயலி நேரத்தை ஒதுக்குவதை நிறுத்துகிறது. இது நிகழும்போது, ​​ஷெல் ஒரு SIGINT சமிக்ஞையை அனுப்புவதன் மூலம் செயல்முறைகளை அறிவிக்கிறது.

பாஷ் ஸ்கிரிப்டுகள் இந்த சிக்னல்களைக் கட்டுப்படுத்தாது, ஆனால் அவை அவற்றை அடையாளம் கண்டு சில கட்டளைகளை இயக்கி சிக்னல்களால் ஏற்படும் விளைவுகளுக்கு ஸ்கிரிப்டைத் தயாரிக்கலாம்.

ஸ்கிரிப்ட்டுகளுக்கு சிக்னல்களை அனுப்புகிறது

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

ஒரு செயல்முறையை நிறுத்துதல்

சேர்க்கை CTRL விசைகள்+C ஆனது SIGINT சிக்னலை உருவாக்கி, ஷெல்லில் இயங்கும் அனைத்து செயல்முறைகளுக்கும் அனுப்புகிறது, இதனால் அவை நிறுத்தப்படும்.

ஷெல்லில் பின்வரும் கட்டளையை இயக்குவோம்:

$தூக்கம் 100
அதன் பிறகு, CTRL + C என்ற முக்கிய கலவையுடன் அதன் வேலையை முடிப்போம்.

விசைப்பலகையில் ஒரு செயல்முறையை நிறுத்தவும்

செயல்முறையை தற்காலிகமாக நிறுத்துதல்

CTRL + Z விசை சேர்க்கை SIGTSTP சமிக்ஞையை உருவாக்குகிறது, இது செயல்முறையை இடைநிறுத்துகிறது ஆனால் அதை நிறுத்தாது. அத்தகைய செயல்முறை நினைவகத்தில் உள்ளது மற்றும் அதன் வேலையை மீண்டும் தொடங்கலாம். ஷெல்லில் கட்டளையை இயக்குவோம்:

$தூக்கம் 100
CTRL + Z என்ற முக்கிய கலவையுடன் தற்காலிகமாக அதை நிறுத்தவும்.

செயல்முறையை இடைநிறுத்தவும்

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

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

பின்வரும் கட்டளையுடன் இடைநிறுத்தப்பட்ட வேலைகளை நீங்கள் பார்க்கலாம்:

பிஎஸ் -எல்

பணி பட்டியல்

செயல்முறை நிலையைக் காட்டும் S நெடுவரிசையில், இடைநிறுத்தப்பட்ட செயல்முறைகளுக்கு T காட்டப்படும். கட்டளை இடைநிறுத்தப்பட்டுள்ளது அல்லது சுவடு நிலையில் இருப்பதை இது குறிக்கிறது.

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

அவளுடைய அழைப்பு இதுபோல் தெரிகிறது:

செயலி ஐடியைக் கொல்லுங்கள்

சிக்னல் குறுக்கீடு

ஸ்கிரிப்ட்டில் லினக்ஸ் சிக்னல் கண்காணிப்பை இயக்க, ட்ராப் கட்டளையைப் பயன்படுத்தவும். இந்த கட்டளையை அழைக்கும் போது குறிப்பிடப்பட்ட சிக்னலை ஸ்கிரிப்ட் பெற்றால், அது சுயாதீனமாக செயலாக்குகிறது, ஷெல் அத்தகைய சமிக்ஞையை செயலாக்காது.

ட்ராப் கட்டளையானது ஸ்கிரிப்டை அதன் தலையீடு இல்லாமல் ஷெல் மூலம் செயலாக்கப்படும் சிக்னல்களுக்கு பதிலளிக்க அனுமதிக்கிறது.

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

#!/bin/bash trap "echo " Trapped Ctrl-C"" SIGINT echo இது ஒரு சோதனை ஸ்கிரிப்ட் எண்ணிக்கை=1 ஆகும் போது [ $count -le 10 ] echo "Loop #$count" தூக்கம் 1 count=$(($ எண்ணிக்கை + 1)) முடிந்தது
இந்த எடுத்துக்காட்டில் பயன்படுத்தப்படும் ட்ராப் கட்டளை வெளியிடுகிறது உரை செய்திஅது ஒரு SIGINT சிக்னலைக் கண்டறியும் போதெல்லாம், விசைப்பலகையில் Ctrl + C ஐ அழுத்துவதன் மூலம் உருவாக்க முடியும்.

சிக்னல் குறுக்கீடு

ஒவ்வொரு முறையும் நீங்கள் CTRL + C ஐ அழுத்தினால், ஸ்கிரிப்ட் ட்ரேஸை அழைக்கும் போது குறிப்பிடப்பட்ட எதிரொலி கட்டளையை ஷெல்லை நிறுத்த விடாமல் செயல்படுத்துகிறது.

ட்ராப் கட்டளையை அழைக்கும் போது EXIT சிக்னலின் பெயரைப் பயன்படுத்தி ஸ்கிரிப்ட் வெளியேறும் சமிக்ஞையை இடைமறிக்கலாம்:

#!/bin/bash trap "echo Goodbye..." EXIT count=1 while [ $count -le 5 ] do echo "Loop #$count" sleep 1 count=$(($count + 1)) முடிந்தது

ஸ்கிரிப்ட் வெளியேறும் சமிக்ஞையை இடைமறித்தல்

ஸ்கிரிப்ட் வெளியேறும்போது, ​​​​சாதாரணமாக அல்லது ஒரு SIGINT சமிக்ஞை காரணமாக, ஷெல் எதிரொலி கட்டளையை இடைமறித்து செயல்படுத்தும்.

இடைமறித்த சமிக்ஞைகளின் மாற்றம் மற்றும் இடைமறிப்பு ரத்து

ஸ்கிரிப்ட் மூலம் இடைமறித்த சிக்னல்களை மாற்ற, புதிய அளவுருக்கள் மூலம் ட்ராப் கட்டளையை இயக்கலாம்:

#!/bin/bash trap "echo "Ctrl-C is trapped."" SIGINT count=1 while [ $count -le 5 ] do echo "Loop #$count" sleep 1 count=$(($count + 1) ) செய்யப்பட்ட பொறி "எதிரொலி "நான் பொறியை மாற்றியமைத்தேன்!"" SIGINT எண்ணிக்கை=1 போது [ $count -le 5 ] do echo "Second Loop #$count" sleep 1 count=$(($count + 1)) முடிந்தது

சிக்னல் இடைமறிப்பு மாற்றம்

மாற்றத்திற்குப் பிறகு, சிக்னல்கள் புதிய வழியில் செயலாக்கப்படும்.

ட்ராப் கட்டளையை இயக்கி, இரட்டை கோடு மற்றும் சிக்னல் பெயரை அனுப்புவதன் மூலமும் சிக்னல் இடைமறிப்பு ரத்து செய்யப்படலாம்:

#!/bin/bash trap "echo "Ctrl-C is trapped."" SIGINT count=1 while [ $count -le 5 ] do echo "Loop #$count" sleep 1 count=$(($count + 1) ) செய்த பொறி -- SIGINT எதிரொலி "நான் பொறியை அகற்றினேன்" எண்ணிக்கை=1 போது [ $count -le 5 ] do echo "Second Loop #$count" sleep 1 count=$(($count + 1)) முடிந்தது
குறுக்கீடு ரத்து செய்யப்படுவதற்கு முன்பு ஸ்கிரிப்ட் ஒரு சமிக்ஞையைப் பெற்றால், அது குறிப்பிட்டபடி அதைச் செயல்படுத்தும் தற்போதைய அணிபொறி. ஸ்கிரிப்டை இயக்குவோம்:

$./மைஸ்கிரிப்ட்
மற்றும் விசைப்பலகையில் CTRL + C ஐ அழுத்தவும்.

இடைமறிப்பு ரத்து செய்யப்படுவதற்கு முன்பு சிக்னல் குறுக்கிடப்பட்டது.

CTRL + C இன் முதல் அழுத்தமானது ஸ்கிரிப்ட் செயல்பாட்டின் போது ஏற்பட்டது, சிக்னல் இடைமறிப்பு நடைமுறையில் இருந்ததால், சிக்னலுக்கு ஒதுக்கப்பட்ட எதிரொலி கட்டளையை ஸ்கிரிப்ட் செயல்படுத்தியது. செயல்படுத்தல் அன்ஹூக் கட்டளையை அடைந்த பிறகு, CTRL + C கட்டளை வழக்கம் போல் வேலை செய்தது, ஸ்கிரிப்டை நிறுத்தியது.

பின்னணியில் கட்டளை வரி ஸ்கிரிப்ட்களை இயக்குகிறது

சில நேரங்களில் பாஷ் ஸ்கிரிப்டுகள் ஒரு பணியை முடிக்க நீண்ட நேரம் எடுக்கும். இருப்பினும், ஸ்கிரிப்ட் முடிவடையும் வரை காத்திருக்காமல் கட்டளை வரியில் நீங்கள் சாதாரணமாக வேலை செய்ய வேண்டியிருக்கலாம். செயல்படுத்துவது அவ்வளவு கடினம் அல்ல.

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

#!/பின்/பாஷ் எண்ணிக்கை=1 போது [ $count -le 10 ] தூங்கு 1 எண்ணிக்கை=$(($count + 1)) முடிந்தது
பெயருக்குப் பிறகு ஆம்பர்சண்ட் எழுத்தைக் (&) குறிப்பிட்டு அதை இயக்குவோம்:

$./myscip &
இது ஒரு பின்னணி செயல்முறையாக இயங்க வைக்கும்.

பின்னணியில் ஒரு ஸ்கிரிப்டை இயக்குகிறது

ஸ்கிரிப்ட் பின்னணி செயல்பாட்டில் தொடங்கப்படும், அதன் அடையாளங்காட்டி முனையத்தில் காட்டப்படும், அதன் செயலாக்கம் முடிந்ததும், இதைப் பற்றிய செய்தியை நீங்கள் காண்பீர்கள்.

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

செயல்முறைகளின் பட்டியல்

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

டெர்மினலை மூடிய பிறகு ஸ்கிரிப்ட் தொடர்ந்து இயங்க வேண்டுமானால் என்ன செய்வது?

முனையத்தை மூடும் போது வெளியேறாத ஸ்கிரிப்ட்களை இயக்குதல்

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

எங்கள் ஸ்கிரிப்டை இயக்கும்போது இந்த நுட்பத்தைப் பயன்படுத்துவோம்:

நோஹப் ./மைஸ்கிரிப்ட் &
இதுதான் டெர்மினலுக்கு வெளியீடாக இருக்கும்.

குழு nohup

nohup கட்டளை டெர்மினலில் இருந்து ஒரு செயல்முறையை வெளிப்படுத்துகிறது. இதன் பொருள், செயல்முறை STDOUT மற்றும் STDERRக்கான குறிப்புகளை இழக்கும். ஸ்கிரிப்ட் மூலம் தரவு வெளியீட்டை இழக்காமல் இருக்க, nohup தானாகவே STDOUT மற்றும் STDERR இல் வரும் செய்திகளை nohup.out கோப்பிற்கு திருப்பிவிடும்.

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

பணிகளைப் பார்க்கவும்

ஷெல்லில் இயங்கும் தற்போதைய வேலைகளைப் பார்க்க வேலைகள் கட்டளை உங்களை அனுமதிக்கிறது. பின்வரும் ஸ்கிரிப்டை எழுதுவோம்:

#!/bin/bash count=1 போது [ $count -le 10 ] do echo "Loop #$count" sleep 10 count=$(($count + 1)) முடிந்தது
அதை இயக்குவோம்:

$./மைஸ்கிரிப்ட்
CTRL + Z என்ற முக்கிய கலவையுடன் தற்காலிகமாக அதை நிறுத்தவும்.

ஸ்கிரிப்டை இயக்குதல் மற்றும் இடைநிறுத்துதல்

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

$ ./myscript > outfile &
இப்போது வேலைகள் கட்டளையை இயக்குவதன் மூலம், இடைநிறுத்தப்பட்ட ஸ்கிரிப்ட் மற்றும் பின்னணியில் இயங்கும் இரண்டும் பற்றிய தகவலைப் பார்ப்போம்.

ஸ்கிரிப்ட்களைப் பற்றிய தகவல்களைப் பெறுதல்

வேலைகள் கட்டளையை அழைக்கும் போது -l சுவிட்ச் செயல்முறை ஐடிகள் பற்றிய தகவல் தேவை என்பதைக் குறிக்கிறது.

இடைநிறுத்தப்பட்ட வேலைகளை மீண்டும் தொடங்குதல்

பின்னணியில் ஸ்கிரிப்டை மறுதொடக்கம் செய்ய, நீங்கள் bg கட்டளையைப் பயன்படுத்தலாம்.

ஸ்கிரிப்டை இயக்குவோம்:

$./மைஸ்கிரிப்ட்
CTRL + Z ஐ அழுத்தவும், இது அதன் செயல்பாட்டை தற்காலிகமாக நிறுத்தும். பின்வரும் கட்டளையை இயக்குவோம்:

$bg

bg கட்டளை

ஸ்கிரிப்ட் இப்போது பின்னணியில் இயங்குகிறது.

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

ஒரு வேலையை மீண்டும் தொடங்குவதற்கு சாதாரண பயன்முறை fg கட்டளையைப் பயன்படுத்தவும்:

ஸ்கிரிப்ட்களை இயக்க திட்டமிடுகிறது

லினக்ஸ் ஒரு குறிப்பிட்ட நேரத்தில் பாஷ் ஸ்கிரிப்ட்களை இயக்க இரண்டு வழிகளை வழங்குகிறது. இவை அட் கமாண்ட் மற்றும் கிரான் ஜாப் ஷெட்யூலர்.

at கட்டளை இதுபோல் தெரிகிறது:

[-f கோப்பு பெயர்] நேரத்தில்
இந்த கட்டளை பல நேர வடிவங்களை அங்கீகரிக்கிறது.

• ஸ்டாண்டர்ட், மணிநேரங்களையும் நிமிடங்களையும் குறிக்கிறது, எடுத்துக்காட்டாக - 10:15.
• AM/PM குறிகாட்டிகளைப் பயன்படுத்துதல், மதியத்திற்கு முன் அல்லது பின், உதாரணமாக - 10:15PM.
• இப்போது , நண்பகல் , நள்ளிரவு போன்ற சிறப்புப் பெயர்களைப் பயன்படுத்துதல் .

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

• MMDDYY, MM/DD/YY, அல்லது DD.MM.YY வடிவங்களைப் பயன்படுத்தி தேதி எழுதப்படும் நிலையான தேதி வடிவம்.
• தேதியின் உரைப் பிரதிநிதித்துவம், எடுத்துக்காட்டாக, ஜூலை 4 அல்லது டிசம்பர் 25, ஆண்டு குறிப்பிடப்படலாம் அல்லது அது இல்லாமல் செய்யலாம்.
• இப்போது போல பதிவு + 25 நிமிடங்கள் .
• நாளை இரவு 10:15 மணிக்கு பதிவு காட்சி.
• பதிவு வகை 10:15 + 7 நாட்கள்.

இந்த தலைப்பில் ஆழமாக செல்ல வேண்டாம், கட்டளைக்கான எளிய பயன்பாட்டு வழக்கைப் பார்ப்போம்:

$ at -f ./myscript இப்போது

at கட்டளையைப் பயன்படுத்தி வேலைகளை திட்டமிடுதல்

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

செயல்படுத்தக் காத்திருக்கும் வேலைகளின் பட்டியலைப் பார்க்க, நீங்கள் atq கட்டளையைப் பயன்படுத்தலாம்:

நிலுவையில் உள்ள பணிகளின் பட்டியல்

நிலுவையில் உள்ள வேலைகளை நீக்குதல்

நிலுவையில் உள்ள வேலையை நீக்குவதற்கு atrm கட்டளை உங்களை அனுமதிக்கிறது. அதை அழைக்கும்போது, ​​பணி எண்ணைக் குறிப்பிடவும்:

$atrm 18

ஒரு வேலையை நீக்குதல்

ஒரு அட்டவணையில் ஸ்கிரிப்ட்களை இயக்கவும்

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

லினக்ஸில் க்ரான்டாப் பயன்பாடு உள்ளது, இது தொடர்ந்து இயக்க வேண்டிய ஸ்கிரிப்ட்களை திட்டமிட உங்களை அனுமதிக்கிறது.

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

ஏற்கனவே உள்ள கிரான் வேலை அட்டவணையைப் பார்க்க, பின்வரும் கட்டளையைப் பயன்படுத்தவும்:

$ crontab -l
ஸ்கிரிப்டை ஒரு அட்டவணையில் இயக்க திட்டமிடும் போது, ​​பின்வரும் வடிவமைப்பில் வேலையை எப்போது செயல்படுத்த வேண்டும் என்பது பற்றிய தரவை crontab ஏற்றுக்கொள்கிறது:

நிமிடம், மணிநேரம், மாதத்தின் நாள், மாதம், வாரத்தின் நாள்.
எடுத்துக்காட்டாக, ஒரு குறிப்பிட்ட ஸ்கிரிப்ட் என்ற கட்டளையை ஒவ்வொரு நாளும் 10:30 மணிக்கு இயக்க வேண்டும் என நீங்கள் விரும்பினால், இது பணி அட்டவணையில் பின்வரும் உள்ளீட்டிற்கு ஒத்திருக்கும்:

30 10 * * * கட்டளை
இங்கே, மாதம், மாதம் மற்றும் வாரத்தின் நாள் புலங்களுக்குப் பயன்படுத்தப்படும் வைல்டு கார்டு "*" என்பது, கிரான் ஒவ்வொரு மாதமும் ஒவ்வொரு நாளும் காலை 10:30 மணிக்கு கட்டளையை இயக்க வேண்டும் என்பதைக் குறிக்கிறது.

எடுத்துக்காட்டாக, ஒவ்வொரு திங்கட்கிழமையும் மாலை 4:30 மணிக்கு ஸ்கிரிப்ட் இயங்க வேண்டுமெனில், பணி அட்டவணையில் பின்வரும் உள்ளீட்டை நீங்கள் உருவாக்க வேண்டும்:

30 16 * * 1 கட்டளை
வாரத்தின் நாட்களின் எண்ணிக்கை 0 இலிருந்து தொடங்குகிறது, 0 என்றால் ஞாயிறு, 6 என்றால் சனிக்கிழமை. இதோ இன்னொரு உதாரணம். இங்கு ஒவ்வொரு மாதமும் முதல் நாள் மதியம் 12 மணிக்கு கட்டளை செயல்படுத்தப்படும்.

00 12 1 * * கட்டளை
மாதங்கள் 1 முதல் எண்ணப்படுகின்றன.
அட்டவணையில் உள்ளீட்டைச் சேர்க்க, -e சுவிட்ச் மூலம் க்ரான்டாப்பை அழைக்க வேண்டும்:

Crontab –e
பின்னர் நீங்கள் அட்டவணை உருவாக்க கட்டளைகளை உள்ளிடலாம்:

30 10 * * * / home/likegeeks/Desktop/myscript
இந்த கட்டளைக்கு நன்றி, ஸ்கிரிப்ட் ஒவ்வொரு நாளும் 10:30 மணிக்கு அழைக்கப்படும். "வளம் தற்காலிகமாக கிடைக்கவில்லை" பிழையை நீங்கள் சந்தித்தால், கீழே உள்ள கட்டளையை ரூட்டாக இயக்கவும்:

$ rm -f /var/run/crond.pid
பல சிறப்பு கோப்பகங்களைப் பயன்படுத்தி கிரானைப் பயன்படுத்தி ஸ்கிரிப்ட்களின் கால இடைவெளியை இன்னும் எளிதாகத் தொடங்கலாம்:

/etc/cron.hourly /etc/cron.daily /etc/cron.weekly /etc/cron.monthly
அவற்றில் ஒன்றில் ஸ்கிரிப்ட் கோப்பை வைப்பதால், அது முறையே மணிநேரம், தினசரி, வாராந்திர அல்லது மாதாந்திரம் இயங்கும்.

உள்நுழைவு மற்றும் ஷெல் தொடக்கத்தில் ஸ்கிரிப்ட்களை இயக்கவும்

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

$HOME/.bash_profile $HOME/.bash_login $HOME/.profile
உள்நுழைவில் ஒரு ஸ்கிரிப்டை இயக்க, அதன் அழைப்பை .bash_profile கோப்பில் வைக்கவும்.

நீங்கள் ஒரு முனையத்தைத் திறக்கும்போது ஸ்கிரிப்ட்களை இயக்குவது பற்றி என்ன? .bashrc கோப்பு இதை ஒழுங்கமைக்க உதவும்.

முடிவுகள்

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

அன்பான வாசகர்களே! கட்டளை வரி ஸ்கிரிப்ட்களை அட்டவணையில் இயக்குவதற்கு நீங்கள் கருவிகளைப் பயன்படுத்துகிறீர்களா? ஆம் எனில், அவற்றைப் பற்றி எங்களிடம் கூறுங்கள்.

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

கட்டளை வரி இடைமுகத்தை உடனடியாக அணுகும் வகையில் நான் எப்படி பின்னணியில் ஒரு பிரிகேடை இயக்குவது? இயக்க வேண்டிய கட்டாயத்தில் இருக்கும் ஒரு குழுவினர் பின்னணி செயல்முறை என்று அழைக்கப்படுகிறது. பின்னணி செயல்முறைகள் திரையில் காட்டப்படவில்லை. எடுத்துக்காட்டாக, Apache HTTPD சேவையகம் இணையப் பக்கங்களுக்குச் சேவை செய்ய பின்னணியில் இயங்குகிறது. நீங்கள் ஒரு ஷெல் ஸ்கிரிப்ட் அல்லது எந்த கட்டளையையும் குறைந்த முன்னுரிமை பயன்முறையில் வைக்கலாம். கட்டளை வரியின் முடிவில் “&” சேர்ப்பதன் மூலம் ஒரு பணியை (உதாரணமாக, ஒரு குழுவினர் அல்லது ஸ்கிரிப்ட்) பின்னணியில் வைக்கலாம். இந்த அறிக்கை கட்டளையை பின்னணியில் வைத்து டெர்மினலில் இடத்தை விடுவிக்கிறது. பின்னணியில் இயங்கும் ஒரு குழு வேலை என்று அழைக்கப்படுகிறது. பின்னணி கட்டளை இயங்கும் போது, ​​வேறு எந்த கட்டளைகளையும் இயக்க முடியும். தொடரியல் பின்வருமாறு:

கட்டளை & ஸ்கிரிப்ட்-பெயர் & /path/to/command arg1 arg2 & கட்டளை-1 | கட்டளை-2 arg1 & கட்டளை-1 | command-2 -arg1 -arg2 >/path/to/output &

முனைய சாளரத்தைத் தடுக்காமல் பின்னணியில் நிரல்களை இயக்க, நீங்கள் சிறப்பு "&" பயிற்றுவிப்பாளரைப் பயன்படுத்த வேண்டும். கட்டளையின் பெயர், விருப்பத்தேர்வுகள் மற்றும் உள்ளீட்டு அளவுருக்கள் ஆகியவற்றைக் குறிப்பிட்ட பிறகு வரியின் முடிவில் இந்த எழுத்தை வைக்கவும். IN பொதுவான பார்வைஇந்த வரிசையை “command_name -option input_parameter &” என உள்ளிடலாம்.

ls ~/* > ~/test-file.txt &
18960

Enter பொத்தானை அழுத்திய பிறகு, நிரல் தானாகவே பின்னணியில் தொடங்கும். இந்த வழக்கில், முனையம் பின்வரும் உள்ளடக்கத்துடன் ஒரு வரியைக் காண்பிக்கும் “[பணி_எண்] process_identifier” மற்றும் புதிதாக உருவாக்கப்பட்ட கட்டளையை உள்ளிடும்படி கேட்கும்.

லினக்ஸில் பின்னணியில் இயங்கும் கட்டளைகளைக் கண்டறியவும்

பின்வரும் கட்டளையை இயக்கவும்:

தரவு வெளியீட்டின் எடுத்துக்காட்டு:

கண்டுபிடி / -iname "*.c" 2> /dev/null > /tmp/output.txt & இயங்குகிறது
+ இயங்கும் grep -R "hostNamed" / 2> /dev/null > /tmp/grep.txt &

ஆர்டர் அடையாளங்காட்டிகள் எங்கே.

நிலையான காஸ்ட்களுக்கு கூடுதலாக வேலை ஐடிகளுக்கான செயல்முறை ஐடிகளைக் காட்ட, -l விருப்பத்தை அனுப்பவும்:

தரவு வெளியீட்டின் எடுத்துக்காட்டு:

7307 ரன்னிங் ஃபைண்ட் / -iname "*.c" 2> /dev/null > /tmp/output.txt &
+ 7324 இயங்கும் grep -R "hostNamed" / 2> /dev/null > /tmp/grep.txt &

செயல்முறை ஐடிகளை மட்டும் காட்ட, உள்ளிடவும்:

தரவு வெளியீட்டின் எடுத்துக்காட்டு:

பின்னணியில் இயங்கும் கட்டளைகளை இயக்குவதை நிறுத்துங்கள்

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

PID ஐ கொல்லுங்கள்
கொல்ல -15 PID
கொல்ல -9 PID
கொல்லும் செயல்முறை-பெயர்-இங்கே
killall -15 செயல்முறை-பெயர்-இங்கே
killall -9 செயல்முறை-பெயர்-இங்கே

லினக்ஸில் ஒரு நிரலை முன்பக்க பயன்முறைக்கு திருப்பி அனுப்புகிறது

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

கண்டுபிடி / -name .ini 2> ~/results.txt &
19090
fg 1
bash: fg: பணி முடிந்தது
+ 1 கண்டுபிடிப்பிலிருந்து வெளியேறு / -name .ini 2> ~/results.txt

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

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

அனைத்து நிரல்களையும் பல வகைகளாகப் பிரிக்கலாம்:

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

இப்போது நிரல்களைத் தொடங்குவதற்கு செல்லலாம்.

முனையத்தில் நிரல்களை இயக்குகிறது

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

/path/to/file/programவிருப்பங்கள்

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

டெவலப்பர்கள் ஒரு தீர்வைக் கொண்டு வந்துள்ளனர். ஒரு PATH மாறி உருவாக்கப்பட்டது, இது நிரல்கள் பொதுவாக அமைந்துள்ள கோப்புறைகளுக்கான அனைத்து பாதைகளையும் சேமிக்கிறது - /bin, /sbin, /usr/bin, /usr/sbin மற்றும் பல. கட்டளையுடன் அதன் உள்ளடக்கங்களை நீங்கள் பார்க்கலாம்:

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

ஒரு இடைவெளிக்குப் பிறகு நீங்கள் அளவுருக்களை அனுப்பலாம்:

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

/usr/local/bin/ls1

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

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

variable_name = மதிப்பு கட்டளை

உதாரணத்திற்கு:

எடிட்டர்=நானோ விசுடோ

இயல்பாக, இந்த கட்டளை விம் எடிட்டரில் அமைப்புகளைத் திறக்கிறது, ஆனால் இதனுடன் சுற்றுச்சூழல் மாறிஅமைப்புகள் நானோ எடிட்டரில் திறக்கப்படும்.

மற்றொரு பயனராக நிரல்களை இயக்குகிறது

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

sudo கட்டளை
சுடோ ஹூமி

ஆனால் -u விருப்பத்தைப் பயன்படுத்தி, கணினியில் உள்நுழைந்துள்ள எந்தவொரு பயனராகவும் நிரலை இயக்கலாம்:

sudo -u பயனர்பெயர் கட்டளை
sudo -u postgres whoami

Whoami (who am I) கட்டளை தற்போதைய பயனரின் பெயரைக் காட்டுகிறது.

பின்னணியில் ஒரு நிரலை எவ்வாறு இயக்குவது

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

நிரல்_பெயர் &

உதாரணத்திற்கு:

dd if=/dev/zero of=~/file count=100000 &

நிரலின் தனிப்பட்ட அடையாளங்காட்டியான PID ஐ கணினி வெளியிடும், அதை மூடுவதற்கு நீங்கள் பயன்படுத்தலாம்:

லினக்ஸில் ஸ்கிரிப்டை எவ்வாறு இயக்குவது

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

மொழிபெயர்ப்பாளர் /path/to/file/programவிருப்பங்கள்

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

மலைப்பாம்பு hellowrld.py

மேலும் ஜாவா புரோகிராம்கள் இப்படித் தொடங்கப்பட வேண்டும்:

java -jar program.jar

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

அல்லது ஸ்கிரிப்ட்டுக்கான பாதையைத் தட்டச்சு செய்யவும்:

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

sudo chmod u+x ./script.sh

எனவே, பெரும்பாலான விளக்கப்பட்ட நிரல்களுக்கு, எளிய sh ஸ்கிரிப்டுகள் உருவாக்கப்பட்டுள்ளன, அவை விரைவாக தொடங்கப்படலாம்.

GUI இல் லினக்ஸ் நிரல்களை இயக்குதல்

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

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

ஸ்கிரிப்ட்களை இயக்குகிறது வரைகலை இடைமுகம். /usr/share/applications/ கோப்பகத்தில் அனைத்து மெனு குறுக்குவழிகளையும் நீங்கள் காணலாம். இங்கிருந்து இருமுறை கிளிக் செய்வதன் மூலம் எந்த நிரலையும் தொடங்கலாம். ஆனால் குறுக்குவழியில் என்ன இருக்கிறது என்று பார்ப்போம்; இதைச் செய்ய, அதை உரை திருத்தியில் திறக்கவும்:

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

முடிவுரை

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