ທ່ານຕ້ອງການຮູ້ກ່ຽວກັບຂະບວນການຕ່າງໆໃນ Linux [ຄູ່ມືທີ່ສົມບູນແບບ]

ໃນບົດຂຽນນີ້, ພວກເຮົາຈະຍ່າງຜ່ານຄວາມເຂົ້າໃຈຂັ້ນພື້ນຖານກ່ຽວກັບຂັ້ນຕອນຕ່າງໆແລະເບິ່ງສັ້ນໆກ່ຽວກັບວິທີການຈັດການຂັ້ນຕອນໃນ Linux ໂດຍໃຊ້ ຄຳ ສັ່ງບາງຢ່າງ.

ຂະບວນການ ໝາຍ ເຖິງໂຄງການທີ່ ດຳ ເນີນການ; ມັນເປັນຕົວຢ່າງທີ່ເຮັດວຽກຂອງໂປແກຼມ. ມັນຖືກສ້າງຂື້ນຈາກ ຄຳ ແນະ ນຳ ຂອງໂປແກຼມ, ຂໍ້ມູນທີ່ອ່ານຈາກແຟ້ມ, ໂປແກຼມອື່ນຫລືການປ້ອນຂໍ້ມູນຈາກຜູ້ໃຊ້ລະບົບ.

ມີພື້ນຖານສອງປະເພດຂອງຂັ້ນຕອນໃນ Linux:

• ຂະບວນການທາງ ໜ້າ (ຍັງເອີ້ນວ່າເປັນຂະບວນການແບບໂຕ້ຕອບ) - ເຫຼົ່ານີ້ແມ່ນເລີ່ມຕົ້ນແລະຄວບຄຸມໂດຍຜ່ານການປະຊຸມພາກສະ ໜາມ. ເວົ້າອີກຢ່າງ ໜຶ່ງ, ມັນຕ້ອງມີຜູ້ໃຊ້ເຊື່ອມຕໍ່ກັບລະບົບເພື່ອເລີ່ມຕົ້ນຂະບວນການດັ່ງກ່າວ; ພວກເຂົາບໍ່ໄດ້ເລີ່ມຕົ້ນໂດຍອັດຕະໂນມັດເປັນສ່ວນ ໜຶ່ງ ຂອງ ໜ້າ ທີ່/ການບໍລິການຂອງລະບົບ.
• ຂະບວນການປະຫວັດຄວາມເປັນມາ (ຍັງເອີ້ນວ່າຂະບວນການທີ່ບໍ່ມີການໂຕ້ຕອບ/ອັດຕະໂນມັດ) - ແມ່ນຂະບວນການທີ່ບໍ່ໄດ້ເຊື່ອມຕໍ່ກັບສະຖານີ; ພວກເຂົາບໍ່ຄາດຫວັງວ່າຜູ້ໃຊ້ຈະເຂົ້າມາໃຊ້.

ເຫຼົ່ານີ້ແມ່ນປະເພດພິເສດຂອງຂະບວນການພື້ນຫລັງທີ່ເລີ່ມຕົ້ນໃນລະບົບເລີ່ມຕົ້ນແລະສືບຕໍ່ເຮັດວຽກຕະຫຼອດໄປເປັນການບໍລິການ; ພວກເຂົາບໍ່ຕາຍ. ພວກມັນຖືກເລີ່ມຕົ້ນເປັນວຽກງານຂອງລະບົບ (ດຳ ເນີນການເປັນບໍລິການ), ໂດຍເຈດຕະນາ. ເຖິງຢ່າງໃດກໍ່ຕາມ, ພວກເຂົາສາມາດຄວບຄຸມໂດຍຜູ້ໃຊ້ຜ່ານຂັ້ນຕອນການລິເລີ່ມ.

ການສ້າງຂະບວນການໃນ Linux

ຂັ້ນຕອນ ໃໝ່ ແມ່ນຖືກສ້າງຂື້ນຕາມປົກກະຕິເມື່ອຂະບວນການທີ່ມີຢູ່ເຮັດໃຫ້ ສຳ ເນົາຕົວຈິງຂອງມັນຢູ່ໃນ ໜ່ວຍ ຄວາມ ຈຳ. ຂະບວນການເດັກຈະມີສະພາບແວດລ້ອມຄືກັນກັບພໍ່ແມ່ຂອງມັນ, ແຕ່ວ່າພຽງແຕ່ເລກບັດປະ ຈຳ ຕົວຂອງຂະບວນການແມ່ນແຕກຕ່າງກັນ.

ມີສອງວິທີ ທຳ ມະດາທີ່ໃຊ້ໃນການສ້າງຂະບວນການ ໃໝ່ ໃນ Linux:

• ການ ນຳ ໃຊ້ລະບົບ() ຟັງຊັນ - ວິທີການນີ້ຂ້ອນຂ້າງງ່າຍດາຍ, ແຕ່ວ່າມັນບໍ່ມີປະສິດທິພາບແລະມີຄວາມສ່ຽງດ້ານຄວາມປອດໄພທີ່ແນ່ນອນ.
• ການໃຊ້ fork() ແລະ exec() Function - ເຕັກນິກນີ້ແມ່ນກ້າວ ໜ້າ ເລັກ ໜ້ອຍ ແຕ່ມີຄວາມຍືດຫຍຸ່ນ, ຄວາມໄວສູງພ້ອມດ້ວຍຄວາມປອດໄພ.

Linux ລະບຸຂະບວນການແນວໃດ?

ເພາະວ່າ Linux ແມ່ນລະບົບທີ່ມີຜູ້ ນຳ ໃຊ້ຫຼາຍຄົນ, ໝາຍ ຄວາມວ່າຜູ້ ນຳ ໃຊ້ທີ່ແຕກຕ່າງກັນສາມາດເຮັດວຽກໂປຣແກຣມຕ່າງໆໃນລະບົບໄດ້, ແຕ່ລະຕົວຢ່າງທີ່ເຮັດວຽກຂອງໂປແກຼມຕ້ອງຖືກລະບຸໂດຍເອກະລັກໂດຍແກ່ນ.

ແລະໂປແກຼມຖືກລະບຸໂດຍ ID ID ຂອງຂະບວນການຂອງມັນເຊັ່ນດຽວກັນກັບມັນແມ່ນ ID ຂອງຜູ້ປົກຄອງ (PPID), ສະນັ້ນຂັ້ນຕອນຕ່າງໆສາມາດຖືກຈັດເຂົ້າໃນ:

• ຂັ້ນຕອນຂອງພໍ່ແມ່ - ເຫຼົ່ານີ້ແມ່ນຂະບວນການທີ່ສ້າງຂະບວນການອື່ນໆໃນຊ່ວງເວລາທີ່ໃຊ້ເວລາ.
• ຂະບວນການຂອງເດັກ - ຂະບວນການເຫຼົ່ານີ້ຖືກສ້າງຂື້ນໂດຍຂະບວນການອື່ນໆໃນໄລຍະເວລາແລ່ນ.

ຂະບວນການເລີ່ມຕົ້ນແມ່ນແມ່ (ພໍ່ແມ່) ຂອງທຸກໆຂັ້ນຕອນໃນລະບົບ, ມັນແມ່ນໂປແກຼມ ທຳ ອິດທີ່ຖືກປະຕິບັດເມື່ອລະບົບ Linux ຂຶ້ນ; ມັນຄຸ້ມຄອງຂະບວນການອື່ນໆທັງ ໝົດ ໃນລະບົບ. ມັນຖືກເລີ່ມຕົ້ນໂດຍແກ່ນຕົວມັນເອງ, ດັ່ງນັ້ນໃນຫຼັກການມັນບໍ່ມີຂັ້ນຕອນພໍ່ແມ່.

ຂະບວນການລິເລີ່ມມີ ID ຂອງຂະບວນການ 1. ມັນເຮັດ ໜ້າ ທີ່ເປັນພໍ່ແມ່ລ້ຽງ ສຳ ລັບຂະບວນການ ກຳ ພ້າ ກຳ ພ້າທັງ ໝົດ.

ທ່ານສາມາດໃຊ້ ຄຳ ສັ່ງ pidof ເພື່ອຊອກຫາ ID ຂອງຂະບວນການ:

# pidof systemd
# pidof top
# pidof httpd

ເພື່ອຊອກຫາ ID ID ຂອງຂະບວນການແລະ ID process ຂອງພໍ່ແມ່ຂອງຫອຍປະຈຸບັນ, ໃຫ້ແລ່ນ:

$ echo $$
$ echo $PPID

ເມື່ອທ່ານປະຕິບັດຄໍາສັ່ງຫຼືໂປແກຼມ (ຕົວຢ່າງ cloudcmd - CloudCommander), ມັນຈະເລີ່ມຕົ້ນຂັ້ນຕອນໃນລະບົບ. ທ່ານສາມາດເລີ່ມຕົ້ນຂັ້ນຕອນການໂຕ້ຕອບ (ແບບໂຕ້ຕອບ) ໄດ້ດັ່ງຕໍ່ໄປນີ້, ມັນຈະເຊື່ອມຕໍ່ກັບຢູ່ປາຍຍອດແລະຜູ້ໃຊ້ສາມາດສົ່ງຂໍ້ມູນເຂົ້າ:

# cloudcmd

ເພື່ອເລີ່ມຕົ້ນຂັ້ນຕອນໃນພື້ນຫລັງ (ບໍ່ມີການໂຕ້ຕອບ), ໃຊ້ສັນຍາລັກ & , ທີ່ນີ້, ຂັ້ນຕອນນີ້ບໍ່ໄດ້ອ່ານການປ້ອນຂໍ້ມູນຈາກຜູ້ໃຊ້ຈົນກວ່າມັນຈະຖືກຍ້າຍໄປທາງ ໜ້າ.

# cloudcmd &
# jobs

ທ່ານຍັງສາມາດສົ່ງຂັ້ນຕອນໄປຫາພື້ນຫລັງໂດຍການໂຈະມັນໂດຍໃຊ້ [Ctrl + Z] , ນີ້ຈະສົ່ງສັນຍານ SIGSTOP ໄປສູ່ຂັ້ນຕອນ, ດັ່ງນັ້ນຈຶ່ງຢຸດການ ດຳ ເນີນງານຂອງມັນ; ມັນຈະບໍ່ເຮັດວຽກ:

# tar -cf backup.tar /backups/*  #press Ctrl+Z
# jobs

ເພື່ອສືບຕໍ່ ດຳ ເນີນການ ຄຳ ສັ່ງທີ່ໂຈະໄວ້ຂ້າງເທິງໃນພື້ນຫລັງ, ໃຫ້ໃຊ້ ຄຳ ສັ່ງ bg:

# bg

ເພື່ອສົ່ງຂະບວນການພື້ນຫລັງໄປທາງ ໜ້າ, ໃຫ້ໃຊ້ ຄຳ ສັ່ງ fg ພ້ອມດ້ວຍບັດປະ ຈຳ ຕົວຂອງວຽກດັ່ງນັ້ນ:

# jobs
# fg %1

ທ່ານອາດຈະມັກ: ວິທີການເລີ່ມຕົ້ນ Linux Command ໃນຄວາມເປັນມາແລະການຄົ້ນຫາຂັ້ນຕອນໃນ Terminal

ໃນລະຫວ່າງການປະຕິບັດ, ຂະບວນການປ່ຽນຈາກລັດ ໜຶ່ງ ໄປອີກລັດ ໜຶ່ງ ຂື້ນກັບສະພາບແວດລ້ອມ/ສະພາບການຂອງມັນ. ໃນ Linux, ຂະບວນການ ໜຶ່ງ ມີຄວາມເປັນໄປໄດ້ດັ່ງຕໍ່ໄປນີ້:

• ການແລ່ນ - ນີ້ມັນອາດຈະເຮັດວຽກຢູ່ (ມັນແມ່ນຂະບວນການໃນລະບົບປັດຈຸບັນ) ຫຼືພ້ອມທີ່ຈະແລ່ນ (ມັນ ກຳ ລັງລໍຖ້າທີ່ຈະຖືກມອບ ໝາຍ ໃຫ້ເປັນ ໜຶ່ງ ໃນ CPU).
• ລໍຖ້າ - ຢູ່ໃນລັດນີ້, ຂັ້ນຕອນ ໜຶ່ງ ກຳ ລັງລໍຖ້າເຫດການທີ່ເກີດຂື້ນຫຼື ສຳ ລັບຊັບພະຍາກອນຂອງລະບົບ. ນອກຈາກນັ້ນ, ແກ່ນຍັງແຕກຕ່າງລະຫວ່າງສອງປະເພດຂອງຂະບວນການລໍຖ້າ; ຂະບວນການລໍຖ້າທີ່ສາມາດຂັດຂວາງໄດ້ - ສາມາດຖືກລົບກວນໂດຍສັນຍານແລະຂະບວນການລໍຖ້າທີ່ບໍ່ສາມາດລົບກວນໄດ້ - ກຳ ລັງລໍຖ້າໂດຍກົງກັບເງື່ອນໄຂຂອງຮາດແວແລະບໍ່ສາມາດຖືກຂັດຂວາງໂດຍເຫດການ/ສັນຍານໃດໆ.
• ຢຸດ - ຢູ່ໃນລັດນີ້, ຂະບວນການ ໜຶ່ງ ໄດ້ຖືກຢຸດເຊົາ, ໂດຍປົກກະຕິແລ້ວໂດຍໄດ້ຮັບສັນຍານ. ຍົກຕົວຢ່າງ, ຂັ້ນຕອນທີ່ ກຳ ລັງຖືກແກ້ໄຂ.
• ຜີດິບ - ນີ້, ຂັ້ນຕອນທີ່ຕາຍແລ້ວ, ມັນໄດ້ຖືກຢຸດໄປແລ້ວແຕ່ມັນຍັງມີການເຂົ້າໃນຕາຕະລາງຂະບວນການ.

ມັນມີເຄື່ອງມື Linux ຫລາຍ ສຳ ລັບການເບິ່ງ/ລາຍຊື່ທີ່ ກຳ ລັງເຮັດວຽກຢູ່ໃນລະບົບ, ສອງແບບດັ້ງເດີມແລະເປັນທີ່ຮູ້ຈັກກັນດີແມ່ນ ຄຳ ສັ່ງສູງສຸດ:

ມັນສະແດງຂໍ້ມູນກ່ຽວກັບການເລືອກຂະບວນການທີ່ມີການເຄື່ອນໄຫວໃນລະບົບດັ່ງທີ່ສະແດງຢູ່ດ້ານລຸ່ມ:

# ps 
# ps -e | head 

ເບິ່ງແບບເວລາຈິງໆແບບເຄື່ອນໄຫວຂອງລະບົບແລ່ນທີ່ສະແດງຢູ່ໃນ ໜ້າ ຈໍຂ້າງລຸ່ມນີ້:

# top 

ອ່ານນີ້ ສຳ ລັບຕົວຢ່າງການ ນຳ ໃຊ້ທີ່ດີທີ່ສຸດ: 12 ຕົວຢ່າງ ຄຳ ສັ່ງທີ່ໃຊ້ໃນ Linux

glances ແມ່ນເຄື່ອງມືກວດສອບລະບົບ ໃໝ່ ທີ່ຂ້ອນຂ້າງແລະມີຄຸນລັກສະນະຂັ້ນສູງ:

# glances

ສຳ ລັບ ຄຳ ແນະ ນຳ ກ່ຽວກັບການ ນຳ ໃຊ້ທີ່ສົມບູນແບບ, ອ່ານຜ່ານ: Glances - ເຄື່ອງມືກວດສອບລະບົບເວລາທີ່ແທ້ຈິງ ສຳ ລັບ Linux

ມີເຄື່ອງມືກວດສອບລະບົບ Linux ທີ່ມີປະໂຫຍດຫລາຍຢ່າງທີ່ທ່ານສາມາດໃຊ້ເພື່ອລາຍຊື່ຂະບວນການທີ່ມີການເຄື່ອນໄຫວ, ເປີດລິ້ງດ້ານລຸ່ມເພື່ອອ່ານເພີ່ມເຕີມກ່ຽວກັບພວກມັນ:

<

ວິທີການຄວບຄຸມຂະບວນການໃນ Linux

Linux ຍັງມີບາງ ຄຳ ສັ່ງ ສຳ ລັບຄວບຄຸມຂັ້ນຕອນຕ່າງໆເຊັ່ນ: kill, pkill, pgrep ແລະ killall, ຂ້າງລຸ່ມນີ້ແມ່ນຕົວຢ່າງພື້ນຖານ ຈຳ ນວນ ໜຶ່ງ ຂອງວິທີການ ນຳ ໃຊ້ພວກມັນ:

$ pgrep -u tecmint top
$ kill 2308
$ pgrep -u tecmint top
$ pgrep -u tecmint glances
$ pkill glances
$ pgrep -u tecmint glances

ເພື່ອຮຽນຮູ້ວິທີການໃຊ້ ຄຳ ສັ່ງເຫຼົ່ານີ້ຢ່າງເລິກເຊິ່ງ, ເພື່ອຂ້າ/ຢຸດຕິຂະບວນການທີ່ມີການເຄື່ອນໄຫວໃນ Linux, ເປີດລິ້ງຂ້າງລຸ່ມນີ້:

<

ໃຫ້ສັງເກດວ່າທ່ານສາມາດໃຊ້ພວກມັນເພື່ອຂ້າ ຄຳ ຮ້ອງສະ ໝັກ ທີ່ບໍ່ຕອບສະ ໜອງ ໃນ Linux ເມື່ອລະບົບຂອງທ່ານ ໜາວ.

ວິທີການພື້ນຖານຂອງການຄວບຄຸມຂັ້ນຕອນໃນ Linux ແມ່ນໂດຍການສົ່ງສັນຍານໃຫ້ພວກເຂົາ. ມີຫລາຍສັນຍານທີ່ທ່ານສາມາດສົ່ງໄປຫາຂັ້ນຕອນ, ເພື່ອເບິ່ງສັນຍານທັງ ໝົດ ທີ່ເຮັດວຽກ:

$ kill -l

ເພື່ອສົ່ງສັນຍານໄປສູ່ຂັ້ນຕອນ, ໃຊ້ ຄຳ ສັ່ງຂ້າ, pkill ຫຼື pgrep ທີ່ພວກເຮົາໄດ້ກ່າວມາກ່ອນ ໜ້າ ນີ້. ແຕ່ບັນດາໂປແກຼມຕ່າງໆສາມາດຕອບສະ ໜອງ ຕໍ່ສັນຍານເທົ່ານັ້ນຖ້າພວກມັນຖືກຈັດໂປຣແກຣມເພື່ອຮັບຮູ້ສັນຍານເຫລົ່ານັ້ນ.

ແລະສັນຍານສ່ວນໃຫຍ່ແມ່ນໃຊ້ ສຳ ລັບພາຍໃນໂດຍລະບົບ, ຫລື ສຳ ລັບນັກຂຽນໂປແກຼມເມື່ອເຂົາຂຽນລະຫັດ. ຕໍ່ໄປນີ້ແມ່ນສັນຍານທີ່ມີປະໂຫຍດຕໍ່ຜູ້ໃຊ້ລະບົບ:

• SIGHUP 1 - ຖືກສົ່ງໄປຫາຂັ້ນຕອນ ໜຶ່ງ ເມື່ອສະຖານີຄວບຄຸມຂອງມັນຖືກປິດ.
• SIGINT 2 - ຖືກສົ່ງໄປຫາຂັ້ນຕອນໂດຍຈຸດຄວບຄຸມຂອງມັນເມື່ອຜູ້ໃຊ້ຂັດຂວາງຂະບວນການໂດຍການກົດປຸ່ມ [Ctrl + C] .
• SIGQUIT 3 - ຖືກສົ່ງໄປຫາຂັ້ນຕອນຖ້າຜູ້ໃຊ້ສົ່ງສັນຍານຢຸດ [Ctrl + D] .
• SIGKILL 9 - ສັນຍານນີ້ຈະສິ້ນສຸດຂັ້ນຕອນ (ຂ້າ) ທັນທີແລະຂະບວນການນີ້ຈະບໍ່ປະຕິບັດການ ທຳ ຄວາມສະອາດໃດໆ.
• SIGTERM 15 - ນີ້ແມ່ນສັນຍານການຢຸດເຊົາຂອງໂປຣແກຣມ (ຄ່າໃຊ້ຈ່າຍຈະສົ່ງແບບນີ້ໂດຍຄ່າເລີ່ມຕົ້ນ).
• SIGTSTP 20 - ຖືກສົ່ງໄປຫາຂະບວນການໂດຍປະຕູຄວບຄຸມຂອງມັນເພື່ອຂໍໃຫ້ມັນຢຸດ (ຢຸດຢູ່ປາຍຍອດ); ລິເລີ່ມໂດຍຜູ້ໃຊ້ກົດ [Ctrl + Z] .

ຕໍ່ໄປນີ້ແມ່ນຕົວຢ່າງ ຄຳ ສັ່ງຂ້າເພື່ອໃຊ້ໂປແກຼມ Firefox ໂດຍໃຊ້ PID ຂອງມັນເມື່ອມັນ ໝົດ:

$ pidof firefox
$ kill 9 2687
OR
$ kill -KILL 2687
OR
$ kill -SIGKILL 2687  

ເພື່ອຂ້າ ຄຳ ຮ້ອງສະ ໝັກ ທີ່ໃຊ້ຊື່ຂອງມັນ, ໃຫ້ໃຊ້ pkill ຫຼື killall ຄືດັ່ງນີ້:

$ pkill firefox
$ killall firefox 

ໃນລະບົບ Linux, ທຸກໆຂັ້ນຕອນທີ່ມີການເຄື່ອນໄຫວລ້ວນແຕ່ມີບູລິມະສິດແລະມີຄຸນຄ່າທີ່ແນ່ນອນ. ຂະບວນການທີ່ມີບູລິມະສິດສູງກວ່າປົກກະຕິຈະໄດ້ຮັບເວລາ CPU ຫຼາຍກ່ວາຂັ້ນຕອນບູລິມະສິດຕ່ ຳ.

ເຖິງຢ່າງໃດກໍ່ຕາມ, ຜູ້ໃຊ້ລະບົບທີ່ມີສິດທິພິເສດຮາກສາມາດມີອິດທິພົນຕໍ່ສິ່ງນີ້ດ້ວຍ ຄຳ ສັ່ງທີ່ງາມແລະປ່ຽນຊື່.

ຈາກຜົນຜະລິດຂອງ ຄຳ ສັ່ງເທິງ, NI ສະແດງໃຫ້ເຫັນຂະບວນການທີ່ມີຄຸນຄ່າດີ:

$ top  

ໃຊ້ ຄຳ ສັ່ງທີ່ດີເພື່ອ ກຳ ນົດຄ່າທີ່ດີ ສຳ ລັບຂັ້ນຕອນ. ຈົ່ງຈື່ໄວ້ວ່າຜູ້ໃຊ້ປົກກະຕິສາມາດຖືວ່າມີຄຸນຄ່າທີ່ດີຈາກສູນເຖິງ 20 ເຖິງຂະບວນການທີ່ພວກເຂົາເປັນເຈົ້າຂອງ.
ພຽງແຕ່ຜູ້ໃຊ້ຮາກສາມາດໃຊ້ຄຸນຄ່າທີ່ດີໃນທາງລົບ.

ເພື່ອປ່ຽນບຸລິມະສິດຂອງຂະບວນການ ໜຶ່ງ, ໃຫ້ໃຊ້ ຄຳ ສັ່ງ renice ດັ່ງຕໍ່ໄປນີ້:

$ renice +8  2687
$ renice +8  2103

ກວດເບິ່ງບາງບົດຂຽນທີ່ມີປະໂຫຍດຂອງພວກເຮົາກ່ຽວກັບວິທີການຈັດການແລະຄວບຄຸມຂະບວນການ Linux.

<

ດຽວນີ້ ໝົດ ແລ້ວ! ທ່ານມີ ຄຳ ຖາມຫຼືຄວາມຄິດເພີ່ມເຕີມ, ແບ່ງປັນກັບພວກເຮົາຜ່ານແບບຟອມ ຄຳ ຄິດເຫັນດ້ານລຸ່ມ.