මෙහෙයුම් පද්ධති හැඳින්වීම
හේයි හබ්ර්! මම ඔබේ අවධානයට ලිපි මාලාවක් ගෙන ඒමට කැමතියි - මගේ මතය අනුව එක් රසවත් සාහිත්‍යයක පරිවර්තන - OSTEP. මෙම ද්‍රව්‍යය unix වැනි මෙහෙයුම් පද්ධතිවල ක්‍රියාකාරිත්වය, එනම් ක්‍රියාවලි සමඟ වැඩ කිරීම, විවිධ උපලේඛන, මතකය සහ නවීන මෙහෙයුම් පද්ධතියක් සාදන වෙනත් සමාන සංරචක පිළිබඳව ගැඹුරින් සාකච්ඡා කරයි. ඔබට මෙහි සියලුම ද්‍රව්‍යවල මුල් පිටපත දැක ගත හැකිය . පරිවර්ථනය වෘත්තීය නොවන ලෙස (තරමක් නිදහසේ) සිදු කර ඇති බව කරුණාවෙන් සලකන්න, නමුත් මම සාමාන්‍ය අර්ථය රඳවා ගැනීමට බලාපොරොත්තු වෙමි.
මෙම විෂය පිළිබඳ රසායනාගාර කටයුතු මෙහි සොයාගත හැකිය:
වෙනත් අමතර කොටස්:
ඔබට මගේ නාලිකාව ද පරීක්ෂා කළ හැකිය =)
එලාම්! මෙම දේශනය සඳහා රසායනාගාරයක් තිබේ! බලන්න
ක්‍රියාවලි API
UNIX පද්ධතියක ක්‍රියාවලියක් නිර්මාණය කිරීමේ උදාහරණයක් බලමු. එය පද්ධති ඇමතුම් දෙකක් හරහා සිදු වේ දෙබලක () и exec().
ෆෝක් () අමතන්න
දෙබලක () ඇමතුමක් ලබා දෙන වැඩසටහනක් සලකා බලන්න. එය ක්රියාත්මක කිරීමේ ප්රතිඵලය පහත පරිදි වනු ඇත.
පළමුවෙන්ම, අපි ප්රධාන () ශ්රිතය ඇතුල් කර තිරය වෙත තන්තුව මුද්රණය කරමු. රේඛාවේ මුල් පිටපතේ හැඳින්වෙන ක්‍රියාවලි හඳුනාගැනීම අඩංගු වේ PID හෝ ක්‍රියාවලි හඳුනාගැනීම. මෙම හඳුනාගැනීම UNIX හි ක්‍රියාවලියක් වෙත යොමු කිරීමට භාවිතා කරයි. ඊළඟ විධානය fork () ලෙස හැඳින්වේ. මෙම අවස්ථාවේදී, ක්රියාවලියේ පාහේ නිශ්චිත පිටපතක් නිර්මාණය වේ. OS සඳහා, එකම වැඩසටහනේ පිටපත් 2 ක් පද්ධතිය මත ක්රියාත්මක වන බව පෙනේ, එමඟින් fork() ශ්‍රිතයෙන් පිට වේ. අලුතින් සාදන ලද ළමා ක්‍රියාවලිය (එය නිර්මාණය කළ මාපිය ක්‍රියාවලියට අදාළව) ප්රධාන() ශ්‍රිතයෙන් පටන් ගෙන තවදුරටත් ක්රියාත්මක නොවේ. ළමා ක්‍රියාවලියක් යනු මාපිය ක්රියාවලියේ නිශ්චිත පිටපතක් නොවන බව මතක තබා ගත යුතුය; විශේෂයෙන්ම, එයට තමන්ගේම ලිපින ඉඩක්, තමන්ගේම ලේඛන, ක්රියාත්මක කළ හැකි උපදෙස් සඳහා තමන්ගේම දර්ශකයක් සහ වෙනත් දේ ඇත. මේ අනුව, fork() ශ්‍රිතයේ ඇමතුම්කරු වෙත ආපසු ලැබෙන අගය වෙනස් වේ. විශේෂයෙන්ම, මාපිය ක්‍රියාවලියට ළමා ක්රියාවලියේ PID අගය ප්‍රතිලාභයක් ලෙස ලැබෙනු ඇති අතර, දරුවාට 0 ට සමාන අගයක් ලැබෙනු ඇත. මෙම ප්‍රතිලාභ කේත භාවිතා කිරීමෙන්, ඔබට පසුව ක්‍රියාවලීන් වෙන් කර ඒ සෑම එකක්ම තමන්ගේම වැඩ කිරීමට බල කළ හැකිය. . කෙසේ වෙතත්, මෙම වැඩසටහන ක්රියාත්මක කිරීම දැඩි ලෙස අර්ථ දක්වා නැත. ක්‍රියාවලි 2 කට බෙදීමෙන් පසු, මෙහෙයුම් පද්ධතිය ඒවා නිරීක්ෂණය කිරීමට මෙන්ම ඔවුන්ගේ වැඩ සැලසුම් කිරීමට පටන් ගනී. තනි-core ප්‍රොසෙසරයක් මත ක්රියාත්මක කළහොත්, එක් ක්‍රියාවලියක්, මේ අවස්ථාවේ දී මාපියන් දිගටම වැඩ කරනු ඇත, එවිට ළමා ක්‍රියාවලියට පාලනය ලැබෙනු ඇත. නැවත ආරම්භ කරන විට, තත්වය වෙනස් විය හැකිය.
අමතන්න රැඳී සිටින්න()
පහත වැඩසටහන සලකා බලන්න. මෙම වැඩසටහනේදී, ඇමතුමක් තිබීම හේතුවෙන් ඉන්න () මාපිය ක්‍රියාවලිය සැමවිටම ළමා ක්‍රියාවලිය සම්පූර්ණ වන තෙක් බලා සිටිනු ඇත. මෙම අවස්ථාවේදී, අපි තිරය මත දැඩි ලෙස අර්ථ දක්වා ඇති පෙළ ප්රතිදානයක් ලබා ගනිමු
exec() ඇමතුම
අභියෝගය සලකා බලන්න exec(). අපට සම්පූර්ණයෙන්ම වෙනස් වැඩසටහනක් ක්රියාත්මක කිරීමට අවශ්‍ය වූ විට මෙම පද්ධති ඇමතුම ප්‍රයෝජනවත් වේ. මෙන්න අපි අමතන්නෙමු execvp() වචන ගණන් කිරීමේ වැඩසටහනක් වන wc වැඩසටහන ක්රියාත්මක කිරීමට. exec() හැඳින්වූ විට කුමක් සිදුවේද? මෙම ඇමතුම ක්රියාත්මක කළ හැකි ගොනුවේ නම සහ සමහර පරාමිති තර්ක ලෙස යවනු ලැබේ. ඉන්පසු මෙම ක්රියාත්මක කළ හැකි ගොනුවේ කේතය සහ ස්ථිතික දත්ත පූරණය වන අතර කේතය සමඟ එහිම කොටස නැවත ලියනු ලැබේ. අට්ටිය සහ ගොඩ වැනි ඉතිරි මතක ප්‍රදේශ නැවත ආරම්භ කෙරේ. ඉන් පසුව OS විසින් වැඩසටහන සරලව ක්රියාත්මක කර තර්ක මාලාවක් සම්මත කරයි. ඒ නිසා අපි අලුත් ක්‍රියාවලියක් නිර්මාණය කළේ නැහැ, අපි සරලවම දැනට ක්රියාත්මක වන වැඩසටහන වෙනත් ධාවන වැඩසටහනක් බවට පරිවර්තනය කළා. descendant හි exec() ඇමතුම ක්රියාත්මක කිරීමෙන් පසුව, මුල් වැඩසටහන කිසිසේත් ක්රියාත්මක නොවූ බව පෙනේ.
මෙම ආරම්භක සංකූලතාව යුනික්ස් කවචයක් සඳහා සම්පූර්ණයෙන්ම සාමාන්‍ය වන අතර, ඇමතීමෙන් පසු එම කවචයට කේතය ක්රියාත්මක කිරීමට ඉඩ සලසයි දෙබලක (), නමුත් ඇමතුමට පෙර exec(). එවැනි කේතයක් සඳහා උදාහරණයක් වනුයේ එය දියත් කිරීමට පෙර දියත් කෙරෙන වැඩසටහනේ අවශ්‍යතාවලට ෂෙල් පරිසරය සකස් කිරීමයි.
ෂෙල් - පරිශීලක වැඩසටහනක් පමණි. ඇය ඔබට ආරාධනා පත්‍රය පෙන්වා ඔබ එහි යමක් ලියන තෙක් බලා සිටී. බොහෝ අවස්ථාවන්හිදී, ඔබ එහි වැඩසටහනක නම ලිව්වහොත්, කවචය එහි පිහිටීම සොයා ගනී, fork() ක්‍රමය අමතන්න, පසුව නව ක්‍රියාවලියක් නිර්මාණය කිරීමට යම් ආකාරයක exec() වර්ගයක් අමතා එය සම්පූර්ණ වන තෙක් බලා සිටිනු ඇත. රැඳී සිටින්න () ඇමතුම. ළමා ක්‍රියාවලිය පිටවන විට, shell එක wait() ඇමතුමෙන් ආපසු පැමිණ ප්‍රේරකය නැවත මුද්රණය කර ඊළඟ විධානය ඇතුල් කරන තෙක් රැඳී සිටින්න.
fork() & exec() split මගින් shell එකට පහත දේවල් කිරීමට ඉඩ සලසයි, උදාහරණයක් ලෙස:
wc ගොනුව > new_file.
මෙම උදාහරණයේදී, wc වැඩසටහනේ ප්රතිදානය ගොනුවකට හරවා යවනු ලැබේ. කවචය මෙය සාක්ෂාත් කර ගන්නා ආකාරය ඉතා සරලයි - ඇමතීමට පෙර ළමා ක්‍රියාවලියක් නිර්මාණය කිරීමෙන් exec(), කවචය සම්මත ප්රතිදානය වසා ගොනුව විවෘත කරයි new_file, මේ අනුව, තවදුරටත් ධාවනය වන වැඩසටහනෙන් සියලුම ප්රතිදානය wc තිරයක් වෙනුවට ගොනුවකට හරවා යවනු ලැබේ.
Unix පයිප්ප ඔවුන් පයිප්ප () ඇමතුමක් භාවිතා කරන වෙනස සමඟ සමාන ආකාරයකින් ක්රියාත්මක වේ. මෙම අවස්ථාවේදී, ක්රියාවලියේ ප්‍රතිදාන ප්‍රවාහය කර්නලයේ පිහිටා ඇති නල පෝලිමකට සම්බන්ධ වන අතර, වෙනත් ක්‍රියාවලියක ආදාන ප්‍රවාහය සම්බන්ධ වේ.
මූලාශ්රය: www.habr.com