ការណែនាំអំពីប្រព័ន្ធប្រតិបត្តិការ

ហេហេ! ខ្ញុំចង់នាំយកការយកចិត្តទុកដាក់របស់អ្នកនូវស៊េរីនៃអត្ថបទ-ការបកប្រែនៃអក្សរសិល្ប៍គួរឱ្យចាប់អារម្មណ៍មួយនៅក្នុងគំនិតរបស់ខ្ញុំ - OSTEP ។ សម្ភារៈនេះពិភាក្សាយ៉ាងស៊ីជម្រៅអំពីការងាររបស់ប្រព័ន្ធប្រតិបត្តិការដូចយូនីក ពោលគឺធ្វើការជាមួយដំណើរការ កម្មវិធីកំណត់ពេលផ្សេងៗ អង្គចងចាំ និងសមាសធាតុស្រដៀងគ្នាផ្សេងទៀតដែលបង្កើតជាប្រព័ន្ធប្រតិបត្តិការទំនើប។ អ្នកអាចមើលឃើញដើមនៃសម្ភារៈទាំងអស់នៅទីនេះ នៅទីនេះ. សូមចំណាំថាការបកប្រែត្រូវបានធ្វើឡើងដោយគ្មានវិជ្ជាជីវៈ (ដោយសេរី) ប៉ុន្តែខ្ញុំសង្ឃឹមថាខ្ញុំរក្សាបាននូវអត្ថន័យទូទៅ។

ការងារមន្ទីរពិសោធន៍លើប្រធានបទនេះអាចរកបាននៅទីនេះ៖

• ដើម
• ដើម
• ការសម្របខ្លួនផ្ទាល់ខ្លួនរបស់ខ្ញុំ

ផ្នែកផ្សេងទៀត៖

• ផ្នែកទី 1: ការណែនាំ
• ផ្នែកទី 2៖ អរូបី៖ ដំណើរការ
• ផ្នែកទី 3៖ ការណែនាំអំពីដំណើរការ API

អ្នកក៏អាចពិនិត្យមើលឆានែលរបស់ខ្ញុំនៅ ទូរលេខ =)

រោទិ៍! មានបន្ទប់ពិសោធន៍សម្រាប់ការបង្រៀននេះ! មើល github

API ដំណើរការ

សូមក្រឡេកមើលឧទាហរណ៍នៃការបង្កើតដំណើរការនៅក្នុងប្រព័ន្ធយូនីក។ វាកើតឡើងតាមរយៈការហៅប្រព័ន្ធពីរ សម () и exec().

ហៅ fork ()

ពិចារណាកម្មវិធីដែលបង្កើតការហៅ fork() ។ លទ្ធផលនៃការប្រតិបត្តិរបស់វានឹងមានដូចខាងក្រោម។

ដំបូងយើងបញ្ចូលមុខងារ main() ហើយបោះពុម្ពខ្សែអក្សរទៅអេក្រង់។ បន្ទាត់មានកំណត់អត្តសញ្ញាណដំណើរការដែលនៅក្នុងដើមត្រូវបានគេហៅថា PID ឬឧបករណ៍កំណត់អត្តសញ្ញាណដំណើរការ។ ឧបករណ៍កំណត់អត្តសញ្ញាណនេះត្រូវបានប្រើនៅក្នុង UNIX ដើម្បីយោងទៅលើដំណើរការមួយ។ ពាក្យបញ្ជាបន្ទាប់នឹងហៅ fork()។ នៅចំណុចនេះ ច្បាប់ចម្លងស្ទើរតែពិតប្រាកដនៃដំណើរការត្រូវបានបង្កើតឡើង។ សម្រាប់ OS វាហាក់ដូចជាមាន 2 ច្បាប់ចម្លងនៃកម្មវិធីដូចគ្នាដែលកំពុងដំណើរការនៅលើប្រព័ន្ធ ដែលនៅក្នុងវេននឹងចេញពីមុខងារ fork()។ ដំណើរការកូនដែលបានបង្កើតថ្មី (ទាក់ទងនឹងដំណើរការមេដែលបង្កើតវា) នឹងមិនត្រូវបានប្រតិបត្តិទៀតទេ ដោយចាប់ផ្តើមពីមុខងារ main()។ វាគួរតែត្រូវបានចងចាំក្នុងចិត្តថាដំណើរការកូនមិនមែនជាច្បាប់ចម្លងពិតប្រាកដនៃដំណើរការមេ ជាពិសេសវាមានកន្លែងអាសយដ្ឋានផ្ទាល់ខ្លួន បញ្ជីឈ្មោះរបស់វា ទ្រនិចផ្ទាល់ខ្លួនរបស់វាចំពោះការណែនាំដែលអាចប្រតិបត្តិបាន និងអ្វីៗផ្សេងទៀត។ ដូច្នេះតម្លៃដែលត្រលប់ទៅអ្នកហៅមុខងារ fork() នឹងខុសគ្នា។ ជាពិសេស ដំណើរការមេនឹងទទួលបានតម្លៃ PID នៃដំណើរការកុមារជាការត្រឡប់មកវិញ ហើយកុមារនឹងទទួលបានតម្លៃស្មើនឹង 0។ ដោយប្រើលេខកូដត្រឡប់ទាំងនេះ បន្ទាប់មកអ្នកអាចបំបែកដំណើរការ និងបង្ខំពួកគេម្នាក់ៗឱ្យធ្វើការងារផ្ទាល់ខ្លួនរបស់វា។ . ទោះជាយ៉ាងណាក៏ដោយការប្រតិបត្តិនៃកម្មវិធីនេះមិនត្រូវបានកំណត់យ៉ាងតឹងរ៉ឹងទេ។ បន្ទាប់ពីបែងចែកជា 2 ដំណើរការ OS ចាប់ផ្តើមត្រួតពិនិត្យពួកវា ក៏ដូចជារៀបចំផែនការការងាររបស់ពួកគេ។ ប្រសិនបើដំណើរការលើប្រព័ន្ធដំណើរការ single-core ដំណើរការមួយក្នុងចំណោមដំណើរការ ក្នុងករណីនេះ មេនឹងបន្តដំណើរការ ហើយបន្ទាប់មកដំណើរការកុមារនឹងទទួលបានការគ្រប់គ្រង។ នៅពេលចាប់ផ្តើមឡើងវិញ ស្ថានភាពអាចខុសគ្នា។

រង់ចាំការហៅទូរស័ព្ទ ()

ពិចារណាកម្មវិធីខាងក្រោម។ នៅក្នុងកម្មវិធីនេះដោយសារតែមានវត្តមាននៃការហៅមួយ។ រង់ចាំ () ដំណើរការមេនឹងតែងតែរង់ចាំឱ្យដំណើរការកុមារបញ្ចប់។ ក្នុងករណីនេះ យើងនឹងទទួលបានលទ្ធផលអត្ថបទដែលបានកំណត់យ៉ាងតឹងរ៉ឹងនៅលើអេក្រង់

exec() ហៅ

ពិចារណាបញ្ហាប្រឈម exec(). ការហៅប្រព័ន្ធនេះមានប្រយោជន៍នៅពេលយើងចង់ដំណើរការកម្មវិធីខុសគ្នាទាំងស្រុង។ នៅទីនេះយើងនឹងហៅ execvp() ដើម្បីដំណើរការកម្មវិធី wc ដែលជាកម្មវិធីរាប់ពាក្យ។ តើមានអ្វីកើតឡើងនៅពេលដែល exec() ត្រូវបានគេហៅថា? ការហៅទូរសព្ទនេះត្រូវបានឆ្លងកាត់ឈ្មោះឯកសារដែលអាចប្រតិបត្តិបាន និងប៉ារ៉ាម៉ែត្រមួយចំនួនជាអាគុយម៉ង់។ បន្ទាប់ពីនោះកូដ និងទិន្នន័យឋិតិវន្តពីឯកសារដែលអាចប្រតិបត្តិបាននេះត្រូវបានផ្ទុក ហើយផ្នែកផ្ទាល់ខ្លួនរបស់វាជាមួយនឹងកូដត្រូវបានសរសេរជាន់ពីលើ។ តំបន់អង្គចងចាំដែលនៅសេសសល់ ដូចជាជង់ និងហ៊ាត្រូវបានចាប់ផ្តើមឡើងវិញ។ បន្ទាប់ពីនោះ OS ដំណើរការកម្មវិធីដោយឆ្លងកាត់វាបណ្តុំនៃអាគុយម៉ង់។ ដូច្នេះ យើង​មិន​បាន​បង្កើត​ដំណើរ​ការ​ថ្មី​ទេ យើង​គ្រាន់​តែ​បំប្លែង​កម្មវិធី​ដែល​កំពុង​ដំណើរការ​ទៅ​ជា​កម្មវិធី​ដែល​កំពុង​ដំណើរការ​ផ្សេង​ទៀត។ បន្ទាប់ពីដំណើរការ exec() call នៅក្នុង descendant វាហាក់ដូចជាកម្មវិធីដើមមិនដំណើរការទាល់តែសោះ។

ភាពស្មុគស្មាញនៃការចាប់ផ្តើមនេះគឺជារឿងធម្មតាទាំងស្រុងសម្រាប់សែលយូនីក ហើយអនុញ្ញាតឱ្យសែលនោះប្រតិបត្តិកូដបន្ទាប់ពីការហៅទូរសព្ទ សម ()ប៉ុន្តែមុនពេលហៅ exec(). ឧទាហរណ៍នៃកូដបែបនេះនឹងមានការកែតម្រូវបរិយាកាសសែលទៅនឹងតម្រូវការនៃកម្មវិធីដែលកំពុងដំណើរការ មុនពេលចាប់ផ្តើមវា។

សែល - គ្រាន់តែជាកម្មវិធីអ្នកប្រើប្រាស់។ នាងបង្ហាញអ្នកនូវបន្ទាត់អញ្ជើញ ហើយរង់ចាំអ្នកសរសេរអ្វីមួយនៅក្នុងនោះ។ ក្នុងករណីភាគច្រើន ប្រសិនបើអ្នកសរសេរឈ្មោះកម្មវិធីនៅទីនោះ សែលនឹងរកឃើញទីតាំងរបស់វា ហៅវិធីសាស្ត្រ fork() ហើយបន្ទាប់មកហៅប្រភេទមួយចំនួននៃ exec() ដើម្បីបង្កើតដំណើរការថ្មី ហើយរង់ចាំឱ្យវាបញ្ចប់ដោយប្រើ រង់ចាំ () ហៅ។ នៅពេលដែលដំណើរការកូនចេញ សែលនឹងត្រលប់មកវិញពីការហៅ wait() ហើយបោះពុម្ពប្រអប់បញ្ចូលម្តងទៀត ហើយរង់ចាំការបញ្ចូលពាក្យបញ្ជាបន្ទាប់។

ការបំបែក fork() & exec() អនុញ្ញាតឱ្យសែលធ្វើកិច្ចការខាងក្រោម ឧទាហរណ៍៖
ឯកសារ wc > new_file ។

ក្នុងឧទាហរណ៍នេះ លទ្ធផលនៃកម្មវិធី wc ត្រូវបានបញ្ជូនបន្តទៅឯកសារមួយ។ វិធីដែលសែលសម្រេចបាននេះគឺសាមញ្ញណាស់ - ដោយបង្កើតដំណើរការកុមារមុនពេលហៅទូរសព្ទ exec()សែលបិទលទ្ធផលស្តង់ដារ ហើយបើកឯកសារ ឯកសារថ្មីដូច្នេះ លទ្ធផលទាំងអស់ពីកម្មវិធីដែលកំពុងដំណើរការបន្ថែមទៀត wc នឹងត្រូវបានបញ្ជូនបន្តទៅឯកសារជំនួសឱ្យអេក្រង់។

បំពង់យូនីក ត្រូវបានអនុវត្តតាមរបៀបស្រដៀងគ្នាជាមួយនឹងភាពខុសគ្នាដែលពួកគេប្រើ pipe() call ។ ក្នុងករណីនេះ ស្ទ្រីមលទ្ធផលនៃដំណើរការនឹងត្រូវបានភ្ជាប់ទៅជួរបំពង់ដែលមានទីតាំងនៅខឺណែល ដែលចរន្តបញ្ចូលនៃដំណើរការផ្សេងទៀតនឹងត្រូវបានភ្ជាប់។

ប្រភព: www.habr.com