ຄວາມເຂົ້າໃຈເລິກເຊິ່ງຂອງລະບົບ "Ubuntu Linux" - ພວກເຮົາເຫັນສິ່ງນີ້ບໍ?

LINUX ທີ່ພວກເຮົາຮູ້ວ່າແມ່ນລະບົບປະຕິບັດການແລະບໍ່ແມ່ນລະບົບປະຕິບັດການ, ຂົນສົ່ງພ້ອມແຈກຢາຍຫລາຍຢ່າງເຊັ່ນ: Debian, Fedora, Ubuntu ແລະອື່ນໆ. Ubuntu OS ທີ່ພັດທະນາໂດຍ Mark Shuttleworth ແມ່ນເປັນທີ່ຮູ້ຈັກແລະໄດ້ຖືກ ນຳ ໃຊ້ຢ່າງກວ້າງຂວາງຈາກຫຼາຍໆຄົນ. ນອກຈາກນີ້, ການເປັນອິດສະຫຼະແລະ Open Source ເວີຊັ່ນ ໃໝ່ ຂອງມັນແມ່ນອອກເປັນປະ ຈຳ ທຸກປີເຊິ່ງມີສ່ວນຮ່ວມຂອງນັກພັດທະນາຫລາຍພັນຄົນທີ່ປະກອບສ່ວນເຂົ້າໃນການພັດທະນາ. ແຕ່, ມັນເຮັດວຽກໄດ້ແນວໃດ? ທຸກຂະບວນການ, ລາຍຊື່ເຫດການເຮັດໃຫ້ມັນເຮັດວຽກໄດ້ແນວໃດແລະຄວາມ ສຳ ຄັນຂອງຂະບວນການເຫຼົ່ານີ້ແມ່ນຫຍັງ?

ບົດຂຽນນີ້ຈະພາທ່ານເຂົ້າສູ່ລະບົບພາຍໃນຂອງ Ubuntu OS ທີ່ ໜ້າ ສົນໃຈຫຼາຍແລະຈະຊ່ວຍໃຫ້ຈົວມີຄວາມເຂົ້າໃຈກ່ຽວກັບການເຮັດວຽກຂອງມັນ.

ຈັດວາງລົງຂອງລະບົບ

Linux ມີຂັ້ນຕອນ ສຳ ລັບການເຮັດວຽກຂອງມັນ, ແຕ່ລະບໍລິການລະບົບລວມທັງການບໍລິຫານພະລັງງານ, ການບູລະນະ, ການຈັດການກັບອຸປະຕິເຫດຂອງລະບົບແມ່ນຂັ້ນຕອນທີ່ມີເອກະສານຕັ້ງຄ່າໃນ“ /etc/init ” ເຊິ່ງອະທິບາຍເຫດການທີ່ ມັນຈະປະຕິບັດແລະເຫດການທີ່ກົງກັນຂ້າມເຊິ່ງມັນຈະຢຸດການປະຕິບັດຂອງມັນ, ພ້ອມກັບມັນຍັງເກັບຮັກສາເອກະສານການຕັ້ງຄ່າອື່ນໆທີ່ອະທິບາຍເຖິງພຶດຕິ ກຳ ທີ່ໃຊ້ເວລາຂອງມັນຢູ່ໃນລະບົບ "/etc/" ຂອງລະບົບ, ດັ່ງນັ້ນຈຶ່ງສ້າງລະບົບ ເຫດການທີ່ຖືກກະຕຸ້ນ.

ຖ້າມີເຫດການທີ່ເກີດຂື້ນແລ້ວຜູ້ໃດຜູ້ ໜຶ່ງ ຄວນຈະຢູ່ທີ່ນັ້ນເພື່ອຈັບພວກເຂົາແລະປະຕິບັດພວກເຂົາ ?? ແນ່ນອນວ່າຜູ້ຄວບຄຸມແມ່ນຂະບວນການຕົ້ນຕໍຂອງພວກເຮົາທີ່ມີຢູ່ໃນຖານະເປັນພໍ່ແມ່ຂອງທຸກໆຂັ້ນຕອນທີ່ມີ id ຂະບວນການ 1 i.e. init . ນີ້ແມ່ນຂັ້ນຕອນທີ່ເລີ່ມຕົ້ນຈາກລະບົບເລີ່ມຕົ້ນແລະບໍ່ເຄີຍຢຸດ. ຂະບວນການນີ້ເສຍຊີວິດພຽງແຕ່ເມື່ອລະບົບຂັບເຄື່ອນລົງຍ້ອນວ່າບໍ່ມີຂັ້ນຕອນໃດທີ່ເປັນພໍ່ແມ່ຂອງ init.

ຮຸ່ນກ່ອນ ໜ້າ ນີ້ຂອງ Ubuntu ກ່ອນ 6.10 ລວມມີແບບເກົ່າ sysvinit ທີ່ຖືກ ນຳ ໃຊ້ເພື່ອ ດຳ ເນີນການ script ໃນ“ /etc/rcx.d” ໄດເລກະທໍລີໃນທຸກໆລະບົບເລີ່ມຕົ້ນແລະປິດລະບົບ. ແຕ່ຫລັງຈາກນັ້ນລະບົບ upstart ໄດ້ປ່ຽນແທນລະບົບເກົ່າ sysvinit , ແຕ່ຍັງຕອບສະ ໜອງ ຄວາມເຂົ້າກັນ ໃໝ່ ກັບມັນຢູ່.

ຮຸ່ນ Ubuntu ຫຼ້າສຸດມີລະບົບ upstart ນີ້, ແຕ່ວ່ານັບຕັ້ງແຕ່ວິວັດທະນາການຂອງມັນຈາກ Ubuntu 6.10 ມັນໄດ້ຜ່ານການດັດແກ້ຫຼາຍສະບັບທີ່ເປັນ 1.13.2 ຄືໃນວັນທີ 4 ເດືອນກັນຍາປີ 2014. ລະບົບ upstart ລ້າສຸດ ມີ 2 init ຂະບວນການ ໜຶ່ງ, ສຳ ລັບຂັ້ນຕອນຂອງລະບົບແລະອື່ນໆທີ່ຄວບຄຸມການເຂົ້າສູ່ລະບົບຂອງຜູ້ໃຊ້ທີ່ມີຢູ່ໃນປະຈຸບັນແລະມີພຽງແຕ່ຈົນກວ່າຜູ້ໃຊ້ຈະເຂົ້າສູ່ລະບົບ, ຍັງເອີ້ນວ່າ x-session init .

ລະບົບທັງ ໝົດ ໄດ້ຖືກຈັດວາງເປັນລະບົບ ລຳ ດັບຊັ້ນ, ປະກອບດ້ວຍຄວາມ ສຳ ພັນຂອງບັນພະບຸລຸດ - ເດັກຕະຫຼອດໄລຍະໄຟຟ້າຈົນເຖິງ ອຳ ນາດຂອງລະບົບ.

ຍົກຕົວຢ່າງ : ຄວາມ ສຳ ພັນແບບ ລຳ ດັບນ້ອຍໆລະຫວ່າງທັງສອງຂັ້ນຕອນແມ່ນ: ລະບົບ init (1) -> ຜູ້ຈັດການການສະແດງ (ພື້ນທີ່ຂອງ kernel) -> ຜູ້ຈັດການການສະແດງ (ພື້ນທີ່ຂອງຜູ້ໃຊ້) -> ຜູ້ ນຳ init (ຫຼື x- ພາກເລີ່ມຕົ້ນ).

ເອກະສານການຕັ້ງຄ່າ ສຳ ລັບຂັ້ນຕອນທີ່ຈັດການໂດຍລະບົບ init ຢູ່ໃນ "/etc/init " ແລະ ສຳ ລັບຜູ້ທີ່ຖືກຈັດການໂດຍ init session ແມ່ນຢູ່ໃນ "/usr/share/upstart " (ຄື ຕໍ່ກັບເວີຊັນ upstart ປັດຈຸບັນຢູ່ຂ້າງເທິງ 1.12 ) ແລະເອກະສານການຕັ້ງຄ່າເຫລົ່ານີ້ແມ່ນກຸນແຈ ສຳ ຄັນຕໍ່ຄວາມລັບທີ່ບໍ່ສາມາດເວົ້າໄດ້ກ່ຽວກັບຂະບວນການຕ່າງໆດັ່ງທີ່ໄດ້ອະທິບາຍໄວ້ໃນບົດຄວາມນີ້.

ການເຂົ້າຫາ Deeper ຫຼາຍຂື້ນໃນ ລຳ ດັບຊັ້ນ

Ubuntu ຮັບຮູ້ສອງຂະບວນການ:

<

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

Init ແມ່ນຂະບວນການ ທຳ ອິດທີ່ເລີ່ມຕົ້ນການສະ ໜອງ ໄຟຟ້າໃນລະບົບແລະຖືກຈັດປະເພດພາຍໃຕ້ ບ່ອນເຮັດວຽກແລະຢູ່ ວຽກຍ້ອນວ່າມັນບໍ່ເຄີຍຖືກຂ້າແລະພຽງແຕ່ເວລາທີ່ລິເລີ່ມຖືກຂ້າຕາຍ. powering ລົງ ie init ພຽງແຕ່ເສຍຊີວິດແລະວ່າເກີນໄປຫນຶ່ງຄັ້ງຕໍ່ກອງປະຊຸມແລະວ່າແມ່ນກ່ຽວກັບ powering ລົງ. ກ່ຽວກັບການເພີ່ມພະລັງງານ, init ສ້າງເຫດການ ທຳ ອິດໃນລະບົບ i.e. ງານເລີ່ມຕົ້ນລະບົບ. ແຕ່ລະເອກະສານການຕັ້ງຄ່າໃນ“ /etc/init ” ມີສອງສາຍທີ່ ກຳ ນົດເຫດການທີ່ເຮັດໃຫ້ຂະບວນການເລີ່ມຕົ້ນແລະຢຸດ. ບັນດາສາຍດັ່ງກ່າວແມ່ນໄດ້ຊີ້ໃຫ້ເຫັນໃນຮູບຂ້າງລຸ່ມນີ້:

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

ຂະບວນການທີ່ເລີ່ມຕົ້ນໃນການເລີ່ມຕົ້ນແມ່ນຖືກລະບຸຢູ່ພາຍໃຕ້ແລະເຫຼົ່ານີ້ແມ່ນວຽກທັງ ໝົດ ທີ່ເຮັດວຽກແລະເສຍຊີວິດ:

1 . ຊື່ໂຮດ - ນີ້ແມ່ນຂັ້ນຕອນທີ່ພຽງແຕ່ບອກລະບົບຂອງຊື່ໂຮດຂອງມັນທີ່ຖືກ ກຳ ນົດໄວ້ໃນ/etc/hostname file.

2 . kmod - ໂຫລດໂມດູນ kernel i. e. ຂັບທັງ ໝົດ ຈາກ/etc/modules file.

3 . mountall - ຂະບວນການນີ້ສ້າງຫຼາຍເຫດການແລະມີ ໜ້າ ທີ່ຮັບຜິດຊອບສ່ວນໃຫຍ່ໃນການ ກຳ ນົດລະບົບແຟ້ມເອກະສານທັງ ໝົດ ທີ່ຢູ່ໃນບູດລວມທັງລະບົບແຟ້ມເອກະສານທ້ອງຖິ່ນແລະລະບົບແຟ້ມຂໍ້ມູນຫ່າງໄກສອກຫຼີກ.

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

4 . plymouth - ຂະບວນການນີ້ ດຳ ເນີນການກ່ຽວກັບການເລີ່ມຕົ້ນ mountall ແລະມີຄວາມຮັບຜິດຊອບໃນການສະແດງ ໜ້າ ຈໍສີ ດຳ ທີ່ເຫັນໃນການເລີ່ມຕົ້ນຂອງລະບົບເຊິ່ງສະແດງບາງສິ່ງບາງຢ່າງເຊັ່ນ: ດ້ານລຸ່ມ:

5 . plymouth-ready - ສະແດງວ່າ plymouth ແມ່ນເພີ່ມຂື້ນ.

ປະຕິບັດຕາມຂັ້ນຕອນຕົ້ນຕໍ, ຂະບວນການອື່ນໆທີ່ ດຳ ເນີນການເລີ່ມຕົ້ນປະກອບມີເຊັ່ນ: udev-fallback-graphics , ແລະອື່ນໆ.

1 . init ພ້ອມກັບລຸ້ນສ້າງກິດຈະ ກຳ ເລີ່ມຕົ້ນ.

2 . mountall ທີ່ຢູ່ຕິດຕັ້ງລະບົບແຟ້ມເອກະສານ, plymouth (ພ້ອມກັບ mountall ເລີ່ມຕົ້ນ) ສະແດງ ໜ້າ ຈໍ splash, ແລະ kmod ກຳ ລັງໂຫລດໂມດູນແກ່ນ.

3 . ເຫດການ local-filesystem ທີ່ຜະລິດໂດຍ mountall ເຮັດໃຫ້ dbus ເຮັດວຽກ. (Dbus ແມ່ນລົດເມຂໍ້ຄວາມກວ້າງຂອງລະບົບເຊິ່ງສ້າງເຕົ້າຮັບຊ່ວຍໃຫ້ຂະບວນການອື່ນໆສື່ສານກັນແລະກັນຜ່ານການສົ່ງຂໍ້ຄວາມເຂົ້າໄປໃນຊັອກເກັດນີ້ແລະຜູ້ຮັບຈະໄດ້ຮັບຟັງຂໍ້ຄວາມທີ່ຢູ່ໃນຊັອກເກັດນີ້ແລະກັ່ນຕອງສິ່ງທີ່ມີຄວາມ ໝາຍ ສຳ ລັບມັນ).

4 . local-filesystem ພ້ອມກັບເຫດການເລີ່ມຕົ້ນຂອງ dbus ແລະ static-network-up ທີ່ເກີດຈາກເຄືອຂ່າຍຂະບວນການທີ່ຍັງໃຊ້ງານລະບົບ local-filesystem ເຮັດໃຫ້ຜູ້ຈັດການເຄືອຂ່າຍສາມາດເຮັດວຽກໄດ້.

5 . ເຫດການ ແບບ virtual-filesystem ທີ່ຜະລິດໂດຍ mountall ເຮັດໃຫ້ udev ເຮັດວຽກ. (udev ແມ່ນຜູ້ຈັດການອຸປະກອນ ສຳ ລັບ linux ທີ່ຄວບຄຸມການສຽບຮ້ອນຂອງອຸປະກອນຕ່າງໆແລະມີຄວາມຮັບຜິດຊອບໃນການສ້າງແຟ້ມໃນ/ໄດເລກະທໍລີແລະຈັດການກັບມັນ ນຳ ອີກ.) -filesystems ແລະໄດ້ສ້າງລະບົບແຟ້ມເອກະສານທີ່ເປັນສັນຍານສະແດງໃຫ້ເຫັນເຖິງການຕິດຕັ້ງ/dev directory.

6 . udev ເຮັດໃຫ້ຂົວ upstart-udev ດຳ ເນີນການທີ່ສະແດງໃຫ້ເຫັນວ່າເຄືອຂ່າຍໃນທ້ອງຖິ່ນມີຢູ່ແລ້ວ. ຫຼັງຈາກນັ້ນ, ຫຼັງຈາກທີ່ mountall ໄດ້ ສຳ ເລັດການຕິດຕັ້ງລະບົບແຟ້ມລະບົບສຸດທ້າຍແລະໄດ້ສ້າງເຫດການລະບົບແຟ້ມ.

7 . ເຫດການລະບົບແຟ້ມເອກະສານ ພ້ອມກັບເຫດການເຄືອຂ່າຍແບບຄົງທີ່ເຮັດໃຫ້ວຽກ rc-sysinit ດຳ ເນີນການ. ທີ່ນີ້, ຄວາມເຂົ້າກັນໄດ້ລະຫວ່າງ sysvinit ແລະ upstart ເກົ່າ…

9 . rc-sysinit ແລ່ນ ຄຳ ສັ່ງ telinit ເຊິ່ງບອກລະບົບ runlevel.

10 . ຫຼັງຈາກໄດ້ຮັບເລກ ໝາຍ, init ປະຕິບັດສະຄິບທີ່ເລີ່ມຕົ້ນດ້ວຍ 'S' ຫຼື 'K' (ເລີ່ມຕົ້ນວຽກທີ່ມີ 'S' ໃນຕົ້ນຊື່ຂອງເຂົາແລະຂ້າຜູ້ທີ່ມີ 'K' ໃນຕອນເລີ່ມຕົ້ນຊື່ຂອງພວກເຂົາ) ໃນໄດເລກະທໍລີ/etc/rcX.d (ບ່ອນທີ່ 'X' ແມ່ນລະດັບປະຈຸບັນ).

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

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

ຂ້າງເທິງນີ້ແມ່ນພາກສ່ວນຂອງເອກະສານການຕັ້ງຄ່າຂອງຂະບວນການ mountall. ນີ້ສະແດງໃຫ້ເຫັນເຫດການທີ່ມັນສະແດງອອກ. ຊື່ຂອງເຫດການແມ່ນ ໜຶ່ງ ທີ່ປະສົບຜົນ ສຳ ເລັດຂອງ ຄຳ ວ່າ ‘ ເຫດການ ”. ເຫດການອາດຈະແມ່ນເຫດການ ໜຶ່ງ ທີ່ໄດ້ ກຳ ນົດໄວ້ໃນເອກະສານການຕັ້ງຄ່າດັ່ງທີ່ກ່າວມາຂ້າງເທິງຫຼືສາມາດເປັນຊື່ຂອງຂະບວນການພ້ອມກັບ ຄຳ ນຳ ໜ້າ 'ເລີ່ມຕົ້ນ', "ເລີ່ມຕົ້ນ", "ຢຸດ" ຫຼື "ຢຸດ".

ສະນັ້ນ, ນີ້ພວກເຮົາ ກຳ ນົດສອງເງື່ອນໄຂ:

<

ດັ່ງນັ້ນ, ລຳ ດັບຊັ້ນຈຶ່ງປະຕິບັດຕາມແລະດັ່ງນັ້ນການເພິ່ງພາອາໄສລະຫວ່າງຂະບວນການ:

Event generator (parent) -> Event catcher (child)

ຈົນກ່ວາໃນປັດຈຸບັນ, ທ່ານຕ້ອງເຂົ້າໃຈວິທີການສະຖານະພາບຂອງ ພໍ່ແມ່ - ເດັກ ທີ່ຢູ່ລະຫວ່າງຂັ້ນຕອນຕ່າງໆທີ່ວາງໄວ້ໂດຍ ເຫດການທີ່ເກີດຂື້ນ ກົນໄກໂດຍຜ່ານກົນໄກການເລີ່ມຕົ້ນແບບງ່າຍດາຍ.

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

ສາຍເຫຼົ່ານີ້ຖືກ ນຳ ມາຈາກຂັ້ນຕອນ - ການສ້າງເຄືອຂ່າຍແລະໃນທີ່ນີ້ການເລີ່ມຕົ້ນໃນເງື່ອນໄຂເບິ່ງຄືວ່າສັບສົນເກີນໄປທີ່ປະກອບດ້ວຍຫຼາຍໆເຫດການເຊັ່ນ: ທ້ອງຖິ່ນ - ລະບົບແຟ້ມເອກະສານ , udevtrigger , ບັນຈຸ , runlevel , ເຄືອຂ່າຍ .

ລະບົບແຟ້ມເອກະສານໃນທ້ອງຖິ່ນຖືກປ່ອຍອອກມາໂດຍ mountall, udevtrigger ແມ່ນຊື່ຂອງວຽກ, ເຫດການບັນຈຸຖືກປ່ອຍອອກໂດຍການກວດຫາພາຊະນະ, ເຫດການລະດັບ runlevel ທີ່ປ່ອຍໂດຍ rc-sysinit, ແລະການເຮັດວຽກເຄືອຂ່າຍກໍ່ແມ່ນວຽກອີກຄັ້ງ ໜຶ່ງ.

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

ດັ່ງທີ່ໄດ້ ກຳ ນົດໄວ້ກ່ອນ ໜ້າ ນີ້, ພວກເຮົາສາມາດມີອາຍຸສັ້ນ (ຫລື ວຽກແລະຕາຍ ໄດ້) ຫຼືມີອາຍຸຍືນຍາວ (ຫລື ຢູ່ແລະເຮັດວຽກ ) ແຕ່ວ່າວິທີການ ຈຳ ແນກລະຫວ່າງ ພວກເຂົາ ??

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

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

<