Process

មាតិកា

  1. កម្មវិធី ធៀបនឹង Process
  2. តើ Process មួយមានអ្វីខ្លះ
  3. Process ID
  4. Process នីមួយៗមាន Memory ផ្ទាល់ខ្លួន
  5. ការចែករំលែក CPU៖ Scheduler
  6. Parent Process និង Child Process
  7. របៀបដែល Process មួយបញ្ចប់
  8. Background Process
  9. សាកល្បងដោយខ្លួនឯង

1. កម្មវិធី ធៀបនឹង Process

ពាក្យទាំងពីរនេះស្តាប់ទៅដូចជាអាចប្រើជំនួសគ្នាបាន ប៉ុន្តែវាមានន័យខុសគ្នា៖

  • កម្មវិធី (program) គឺជា file មួយនៅលើ disk ដែលមាន instruction — ដូចជា chrome.exe ឬ /Applications/Telegram.app។ វាគ្រាន់តែនៅស្ងៀម។ វាមិនកំពុងធ្វើអ្វីទេ។
  • Process គឺជាកម្មវិធីដែល កំពុងដំណើរការ៖ វាត្រូវបាន load ចូល RAM ហើយ CPU កំពុងដំណើរការ instruction របស់វា។

សៀវភៅរូបមន្តធ្វើម្ហូបនៅលើធ្នើ គឺជាកម្មវិធី។ មនុស្សម្នាក់ដែលកំពុងចម្អិនម្ហូបតាមវា ដោយមានគ្រឿងផ្សំនៅលើតុ និងឡកំពុងឆេះ គឺជា process។

កម្មវិធីមួយអាចមាន process ច្រើន ក្នុងពេលតែមួយ។ បើក Terminal window បីដាច់ដោយឡែកពីគ្នា អ្នកមាន process បីនៃកម្មវិធីដូចគ្នា។ Chrome ទៅឆ្ងាយជាងនេះ៖ វាដំណើរការ process ដាច់ដោយឡែកសម្រាប់ tab និង extension នីមួយៗដោយចេតនា ដើម្បីកុំឲ្យគេហទំព័រមួយដែលមានបញ្ហា ធ្វើឲ្យ browser ទាំងមូល crash។

2. តើ Process មួយមានអ្វីខ្លះ

នៅពេល OS ចាប់ផ្តើម process មួយ វារៀបចំអ្វីៗទាំងអស់ដែលកម្មវិធីត្រូវការដើម្បីដំណើរការ៖

  • Code — instruction របស់កម្មវិធី ដែលចម្លងពី disk ចូល RAM
  • Memory — កន្លែងសម្រាប់ទិន្នន័យរបស់កម្មវិធី រួមមាន៖
    • stack ដែលតាមដានថា function ណាកំពុងដំណើរការ ហើយផ្ទុក local variable របស់វា
    • heap សម្រាប់ទិន្នន័យដែលបង្កើតឡើងខណៈពេលកម្មវិធីកំពុងដំណើរការ (object, array, string)
  • ស្ថានភាព CPU — តម្លៃក្នុង register និង program counter (bookmark ពីជំពូកទី 3)
  • ធនធានដែលបើក — file ដែលវាបានបើក ការតភ្ជាប់បណ្តាញ ជាដើម
  • អត្តសញ្ញាណ — អ្នកប្រើប្រាស់ណាដែលបានចាប់ផ្តើមវា ដែលកំណត់ថាវាត្រូវបានអនុញ្ញាតឲ្យធ្វើអ្វីខ្លះ

OS តាមដានអ្វីៗទាំងអស់នេះក្នុងកំណត់ត្រាមួយសម្រាប់ process នីមួយៗ ដើម្បីឲ្យវាអាចផ្អាក process ហើយបន្តវាវិញនៅពេលក្រោយ ត្រង់កន្លែងដែលវាឈប់យ៉ាងពិតប្រាកដ។

3. Process ID

Process នីមួយៗទទួលបានលេខតែមួយគត់ហៅថា PID (Process ID)។ OS ប្រើ PID ដើម្បីសំដៅលើ process — ឧទាហរណ៍ ដើម្បីបញ្ឈប់វា ឬពិនិត្យថាវាកំពុងប្រើ memory ប៉ុន្មាន។

PID ត្រូវបានផ្តល់ឲ្យនៅពេល process មួយចាប់ផ្តើម ហើយត្រូវបានដោះលែងនៅពេលវាបញ្ចប់។ បើអ្នកបើក និងបិទកម្មវិធីមួយច្រើនដង ជាធម្មតាវានឹងទទួលបាន PID ខុសគ្នារាល់ពេល។

អ្នកនឹងឃើញ PID ជានិច្ចក្នុងនាមជាអ្នកអភិវឌ្ឍន៍៖ ក្នុង Task Manager ក្នុងសារ error និងនៅពេល command ដូចជា kill 4821 បញ្ឈប់ process ជាក់លាក់មួយ។

4. Process នីមួយៗមាន Memory ផ្ទាល់ខ្លួន

នេះគឺជាគំនិតសំខាន់បំផុតមួយក្នុងស៊េរីទាំងមូល។

Process នីមួយៗ ជឿថាវាមាន memory របស់កុំព្យូទ័រទាំងមូលសម្រាប់ខ្លួនឯង។ នីមួយៗមើលឃើញជួរ address ឯកជនផ្ទាល់ខ្លួន ចាប់ផ្តើមពីសូន្យ។ នេះត្រូវបានហៅថា virtual memory។ នៅពីក្រោយឆាក OS និង CPU បកប្រែ address របស់ process នីមួយៗ ទៅជាទីតាំងពិតក្នុង RAM រូបវន្ត — ទីតាំងខុសគ្នាសម្រាប់ process នីមួយៗ។

Process ពីរអាចប្រើ «address 1000» ទាំងពីរ ហើយមិនដែលប៉ះទង្គិចគ្នាទេ ព្រោះ address 1000 របស់នីមួយៗចង្អុលទៅទីតាំងពិតខុសគ្នា។

វាផ្តល់ឲ្យយើងនូវ៖

  • ភាពដាច់ដោយឡែក (isolation) — process មួយមិនអាចអាន ឬសរសេរជាន់លើ memory របស់ process មួយទៀតបានទេ។ Browser របស់អ្នកមិនអាចលួចមើល memory របស់កម្មវិធីគ្រប់គ្រងពាក្យសម្ងាត់របស់អ្នកបានទេ។
  • ស្ថិរភាព — នៅពេល process មួយ crash ផ្សេងទៀតមិនរងផលប៉ះពាល់ទេ។
  • ភាពបត់បែន — OS អាចផ្លាស់ទី memory ឬផ្លាស់វាចេញទៅ swap (ជំពូកទី 4) ដោយកម្មវិធីមិនដឹងខ្លួន។

បើកម្មវិធីមួយ ពិតជា ព្យាយាមចូលប្រើ memory ដែលមិនមែនជារបស់វា CPU បង្កើត error ហើយ OS បញ្ចប់ process នោះ។ លើ Linux និង macOS នេះគឺជា segmentation fault ដ៏ល្បី («segfault»)។

គុណវិបត្តិនៃភាពដាច់ដោយឡែក គឺ process មិនអាចចែករំលែក variable គ្នាដោយងាយបានទេ។ ដើម្បីសហការគ្នា ពួកវាត្រូវទាក់ទងគ្នាដោយចេតនា — តាមរយៈ file ការតភ្ជាប់បណ្តាញ ឬមុខងារពិសេសរបស់ OS សម្រាប់ inter-process communication (IPC)។

5. ការចែករំលែក CPU៖ Scheduler

Laptop មួយអាចមាន 8 core ប៉ុន្តែមាន process រាប់រយ។ តើពួកវាទាំងអស់ដំណើរការដោយរបៀបណា?

ផ្នែកមួយនៃ kernel ដែលហៅថា scheduler ផ្តល់វេនឲ្យ process នីមួយៗ។ Process មួយដំណើរការលើ core មួយក្នុងរយៈពេលដ៏ខ្លីមួយ — ពីរបី millisecond — ហើយបន្ទាប់មក scheduler ផ្អាកវា រក្សាទុកស្ថានភាព CPU របស់វា ហើយឲ្យ process មួយទៀតដំណើរការ។ ការប្តូរនេះត្រូវបានហៅថា context switch។

វាកើតឡើងលឿនណាស់ — រាប់ពាន់ដងក្នុងមួយវិនាទី — ដែលកម្មវិធីនីមួយៗ មើលទៅ ដូចជាកំពុងដំណើរការជាបន្តបន្ទាប់។ វាដូចជាគ្រូបង្រៀនម្នាក់ដែលឆ្លើយសំណួររបស់សិស្សពេញថ្នាក់ ដោយផ្លាស់ទីពីសិស្សម្នាក់ទៅសិស្សម្នាក់យ៉ាងលឿន។

នៅពេលណាមួយ process មួយស្ថិតក្នុងស្ថានភាពមួយក្នុងចំណោមស្ថានភាពមួយចំនួន៖

  • Running — កំពុងនៅលើ CPU core
  • Ready — អាចដំណើរការបាន កំពុងរង់ចាំវេនរបស់វា
  • Waiting (ឬ blocked) — មិនអាចបន្តបានទេ រហូតដល់មានអ្វីមួយកើតឡើង ដូចជា file មួយ load រួច ឬចម្លើយពីបណ្តាញមកដល់

Process ភាគច្រើននៅលើកុំព្យូទ័ររបស់អ្នក ចំណាយពេលស្ទើរតែទាំងអស់របស់ពួកវាក្នុងការ រង់ចាំ។ កម្មវិធីជជែកមិនធ្វើអ្វីទេ រហូតដល់មានសារមកដល់។ នេះហើយជាមូលហេតុដែលការប្រើប្រាស់ CPU របស់អ្នកជាញឹកញាប់មានតែពីរបីភាគរយ ទោះបីមានកម្មវិធីរាប់សិបកំពុងបើកក៏ដោយ។

6. Parent Process និង Child Process

Process ត្រូវបានចាប់ផ្តើមដោយ process ផ្សេងទៀត។ នៅពេលអ្នកចុចពីរដងលើកម្មវិធីមួយ desktop process សុំ OS ឲ្យចាប់ផ្តើមវា។ នៅពេលអ្នកវាយ command ក្នុង terminal shell របស់ terminal ចាប់ផ្តើមវា។

Process ដែលចាប់ផ្តើមមួយទៀតគឺជា parent ហើយ process ថ្មីគឺជា child។ ដូច្នេះ process ទាំងអស់នៅលើកុំព្យូទ័របង្កើតបានជាមែកធាងគ្រួសារ ដែលត្រឡប់ទៅដល់ process ដំបូងបង្អស់ដែល kernel បានចាប់ផ្តើមក្នុងពេល boot (ជំពូកទី 6)។

ក្នុងនាមជាអ្នកអភិវឌ្ឍន៍ អ្នកនឹងជួបរឿងនេះជានិច្ច៖ ការរត់ npm run dev ចាប់ផ្តើម process មួយ ដែលចាប់ផ្តើម Node.js ដែលអាចចាប់ផ្តើម child process បន្ថែមទៀតរបស់វា។

7. របៀបដែល Process មួយបញ្ចប់

Process មួយអាចបញ្ចប់តាមវិធីពីរបីយ៉ាង៖

  1. វាបញ្ចប់ជាធម្មតា — កម្មវិធីទៅដល់ចុងបញ្ចប់ ហើយ exit។
  2. វា crash — វាធ្វើអ្វីមួយដែលខុសច្បាប់ (ដូចជា segfault) ឬជួប error ដែលគ្មាននរណាដោះស្រាយ ហើយ OS បញ្ចប់វា។
  3. វាត្រូវបានប្រាប់ឲ្យឈប់ — ដោយអ្នក កម្មវិធីផ្សេង ឬ OS។

នៅពេល process មួយ exit វារាយការណ៍ exit code — លេខមួយដែលប្រាប់ parent របស់វាថាអ្វីៗដំណើរការយ៉ាងដូចម្តេច៖

  • 0 មានន័យថាជោគជ័យ
  • លេខផ្សេងទៀត មានន័យថាបរាជ័យប្រភេទណាមួយ — កម្មវិធីជ្រើសរើសថាលេខនីមួយៗមានន័យអ្វី

Exit code សំខាន់ជាងអ្វីដែលអ្នកគិត៖ CI/CD pipeline, Docker និង script សុទ្ធតែពិនិត្យពួកវា ដើម្បីសម្រេចថាជំហានមួយជាប់ ឬធ្លាក់។

នៅពេលអ្នកបញ្ឈប់ process មួយដោយខ្លួនឯង OS ផ្ញើ signal មួយទៅវា — សារខ្លីមួយ។ ពីរដែលអ្នកនឹងប្រើច្រើនជាងគេ (លើ Linux និង macOS)៖

  • SIGTERM — «សូមឈប់»។ កម្មវិធីទទួលបានឱកាសដើម្បីសម្អាត — រក្សាទុកទិន្នន័យ បិទការតភ្ជាប់ — មុនពេល exit។ នេះជាអ្វីដែលការបិទកម្មវិធីធម្មតាធ្វើ។
  • SIGKILL — «ឈប់ឥឡូវនេះ»។ OS បញ្ចប់ process ភ្លាមៗ វាមិនអាចបដិសេធ ឬសម្អាតបានទេ។ នេះគឺជាជម្រើស Force Quit / End task សម្រាប់ពេលកម្មវិធីគាំង។

នៅពេល process មួយបញ្ចប់ — មិនថាវាបញ្ចប់ដោយរបៀបណាទេ — OS យក RAM ទាំងអស់របស់វាមកវិញ បិទ file របស់វា ហើយដោះលែង PID របស់វា។

8. Background Process

Process ជាច្រើនគ្មាន window ទាល់តែសោះ។ ពួកវាដំណើរការយ៉ាងស្ងាត់ៗនៅផ្ទៃខាងក្រោយ ធ្វើការងារដូចជា៖

  • ពិនិត្យរក update
  • sync file ទៅកាន់ cloud
  • ធ្វើ index file របស់អ្នកសម្រាប់ការស្វែងរក
  • ដំណើរការ database ឬ web server

ពួកវាត្រូវបានហៅថា service លើ Windows និង daemon លើ Linux និង macOS (ឈ្មោះ daemon ជាញឹកញាប់បញ្ចប់ដោយ d ដូចជា sshd ឬ dockerd)។

នៅពេលអ្នក deploy កម្មវិធី backend ទៅកាន់ server វាដំណើរការដូចនេះយ៉ាងពិតប្រាកដ៖ background process ដែលដំណើរការយូរ គ្មាន window ហើយរង់ចាំស្តាប់ request។

9. សាកល្បងដោយខ្លួនឯង

បើកកម្មវិធីមើល process របស់អ្នក៖

  • Windows៖ Task Manager (Ctrl + Shift + Esc) → tab Details
  • macOS៖ Activity Monitor → tab CPU
  • Linux៖ រត់ top ឬ ps aux សម្រាប់រូបភាពមួយភ្លែត

បន្ទាប់មក៖

  1. រកជួរឈរ PID។ (លើ Windows វាបង្ហាញនៅ tab Details ក្នុង Activity Monitor វាត្រូវបានហៅថា PID។) តើមាន process ប៉ុន្មានកំពុងដំណើរការសរុប?
  2. រកកម្មវិធីមួយដែលមាន process ច្រើន។ ស្វែងរក browser របស់អ្នក — Chrome, Edge ឬ Safari។ បើក tab បន្ថែមពីរបី ហើយមើល process ថ្មីៗលេចឡើង។
  3. មើល scheduler ធ្វើការ។ តម្រៀបតាម CPU។ Process ភាគច្រើននៅ 0% ព្រោះពួកវាកំពុងរង់ចាំ។
  4. បញ្ចប់ process មួយ។ បើកកម្មវិធីសាមញ្ញមួយដូចជា Calculator រកវាក្នុងបញ្ជី ជ្រើសរើសវា ហើយចុច End task (Windows) ឬប៊ូតុង ✕ → Quit (macOS)។ មើលវាបាត់ពីបញ្ជី និងពីអេក្រង់របស់អ្នក។ សាកល្បង Force Quit ផងដែរ ហើយសម្គាល់ថាកម្មវិធីមិនទទួលបានឱកាសសួរថា «Save changes?» ទេ។

Process គឺជាកម្មវិធីដែលកំពុងដំណើរការ ជាមួយ memory ផ្ទាល់ខ្លួន។ ប៉ុន្តែចុះបើកម្មវិធីមួយត្រូវការធ្វើរឿងច្រើនក្នុងពេលតែមួយ? នោះហើយជាអ្វីដែល thread មានសម្រាប់។

មុនប្រព័ន្ធប្រតិបត្តិការបន្ទាប់Thread និង Concurrency

ទិញកាហ្វេជូនខ្ញុំ

ចូលចិត្តមេរៀននេះមែនទេ? សូមពិចារណាទិញកាហ្វេជូនខ្ញុំមួយកែវ ដើម្បីគាំទ្រការបង្កើតមាតិកាឥតគិតថ្លៃបន្ថែមទៀត!