ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളുടെ ആമുഖം

ഹലോ, ഹബ്ർ! എന്റെ അഭിപ്രായത്തിൽ താൽപ്പര്യമുണർത്തുന്ന ഒരു സാഹിത്യത്തിന്റെ ലേഖനങ്ങളുടെ ഒരു പരമ്പര-വിവർത്തനങ്ങൾ നിങ്ങളുടെ ശ്രദ്ധയിൽപ്പെടുത്താൻ ഞാൻ ആഗ്രഹിക്കുന്നു - OSTEP. ഈ മെറ്റീരിയൽ യുണിക്സ് പോലുള്ള ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളുടെ പ്രവർത്തനം വളരെ ആഴത്തിൽ പരിശോധിക്കുന്നു, അതായത്, പ്രോസസ്സുകൾ, വിവിധ ഷെഡ്യൂളറുകൾ, മെമ്മറി, ഒരു ആധുനിക OS നിർമ്മിക്കുന്ന മറ്റ് സമാന ഘടകങ്ങൾ എന്നിവയുമായി പ്രവർത്തിക്കുക. എല്ലാ മെറ്റീരിയലുകളുടെയും ഒറിജിനൽ നിങ്ങൾക്ക് ഇവിടെ കാണാം ഇവിടെ. വിവർത്തനം പ്രൊഫഷണലായിട്ടല്ല (തീർച്ചയായും സ്വതന്ത്രമായി) നിർമ്മിച്ചിരിക്കുന്നത് എന്നത് ദയവായി ശ്രദ്ധിക്കുക, എന്നാൽ പൊതുവായ അർത്ഥം ഞാൻ നിലനിർത്തിയെന്ന് ഞാൻ പ്രതീക്ഷിക്കുന്നു.

ഈ വിഷയത്തെക്കുറിച്ചുള്ള ലാബ് വർക്ക് ഇവിടെ കാണാം:
- ഒറിജിനൽ: pages.cs.wisc.edu/~remzi/OSTEP/Homework/homework.html
- ഒറിജിനൽ: github.com/remzi-arpacidusseau/ostep-code
- എന്റെ വ്യക്തിപരമായ പൊരുത്തപ്പെടുത്തൽ: github.com/bykvaadm/OS/tree/master/ostep

നിങ്ങൾക്ക് എന്റെ ചാനൽ പരിശോധിക്കാനും കഴിയും ടെലഗ്രാം =)

പ്രോഗ്രാം പ്രവർത്തനം

ഒരു പ്രോഗ്രാം പ്രവർത്തിക്കുമ്പോൾ എന്ത് സംഭവിക്കും? ഒരു പ്രവർത്തിക്കുന്ന പ്രോഗ്രാം ഒരു ലളിതമായ കാര്യം ചെയ്യുന്നു - അത് നിർദ്ദേശങ്ങൾ നടപ്പിലാക്കുന്നു. ഓരോ സെക്കൻഡിലും, ദശലക്ഷക്കണക്കിന്, ഒരുപക്ഷേ കോടിക്കണക്കിന് നിർദ്ദേശങ്ങൾ റാമിൽ നിന്ന് പ്രോസസർ വീണ്ടെടുക്കുന്നു, അതാകട്ടെ അവയെ ഡീകോഡ് ചെയ്യുന്നു (ഉദാഹരണത്തിന്, ഈ നിർദ്ദേശങ്ങൾ ഏത് തരത്തിലാണെന്ന് തിരിച്ചറിയുന്നു) അവ നടപ്പിലാക്കുന്നു. ഇത് രണ്ട് സംഖ്യകൾ ചേർക്കാം, മെമ്മറി ആക്‌സസ് ചെയ്യുക, ഒരു അവസ്ഥ പരിശോധിക്കൽ, ഒരു ഫംഗ്‌ഷനിലേക്ക് ചാടുക, തുടങ്ങിയവ. ഒരു നിർദ്ദേശം പൂർത്തിയാക്കിയ ശേഷം, പ്രോസസ്സർ മറ്റൊന്ന് നടപ്പിലാക്കുന്നതിലേക്ക് നീങ്ങുന്നു. അതിനാൽ നിർദ്ദേശങ്ങൾക്ക് ശേഷമുള്ള നിർദ്ദേശങ്ങൾ, പ്രോഗ്രാം അവസാനിക്കുന്നത് വരെ അവ നടപ്പിലാക്കും.
ഈ ഉദാഹരണം സ്വാഭാവികമായും ഒരു ലളിതമായ രീതിയിൽ പരിഗണിക്കപ്പെടുന്നു - വാസ്തവത്തിൽ, പ്രോസസർ വേഗത്തിലാക്കാൻ, ആധുനിക ഹാർഡ്‌വെയർ നിങ്ങളെ ക്രമത്തിൽ നിന്ന് നിർദ്ദേശങ്ങൾ നടപ്പിലാക്കാനും സാധ്യമായ ഫലങ്ങൾ കണക്കാക്കാനും നിർദ്ദേശങ്ങൾ ഒരേസമയം നടപ്പിലാക്കാനും സമാനമായ തന്ത്രങ്ങളും അനുവദിക്കുന്നു.

വോൺ ന്യൂമാൻ കമ്പ്യൂട്ടേഷൻ മോഡൽ

ഞങ്ങൾ വിവരിച്ച പ്രവർത്തനത്തിന്റെ ലളിതമായ രൂപം കമ്പ്യൂട്ടിംഗിന്റെ വോൺ ന്യൂമാൻ മോഡലിന് സമാനമാണ്. കമ്പ്യൂട്ടർ സിസ്റ്റങ്ങളുടെ തുടക്കക്കാരിൽ ഒരാളാണ് വോൺ ന്യൂമാൻ, ഗെയിം തിയറിയുടെ രചയിതാക്കളിൽ ഒരാളാണ് അദ്ദേഹം.. പ്രോഗ്രാം പ്രവർത്തിക്കുമ്പോൾ, മറ്റ് നിരവധി ഇവന്റുകൾ സംഭവിക്കുന്നു, മറ്റ് നിരവധി പ്രക്രിയകളും മൂന്നാം-കക്ഷി ലോജിക്കും പ്രവർത്തിക്കുന്നു, ഇതിന്റെ പ്രധാന ലക്ഷ്യം സിസ്റ്റത്തിന്റെ സമാരംഭവും പ്രവർത്തനവും പരിപാലനവും ലളിതമാക്കുക എന്നതാണ്.
പ്രോഗ്രാമുകൾ റൺ ചെയ്യുന്നത് എളുപ്പമാക്കുന്നതിന് (അല്ലെങ്കിൽ ഒരേ സമയം ഒന്നിലധികം പ്രോഗ്രാമുകൾ പ്രവർത്തിപ്പിക്കാൻ അനുവദിക്കുക പോലും), പ്രോഗ്രാമുകൾക്ക് ഒരേ മെമ്മറി പങ്കിടാനും അതുപോലെ വ്യത്യസ്ത ഉപകരണങ്ങളുമായി ആശയവിനിമയം നടത്താനും ഉത്തരവാദിത്തമുള്ള ഒരു കൂട്ടം സോഫ്റ്റ്‌വെയർ ഉണ്ട്. അത്തരം ഒരു കൂട്ടം സോഫ്‌റ്റ്‌വെയറിനെ (സോഫ്റ്റ്‌വെയർ) അടിസ്ഥാനപരമായി ഒരു ഓപ്പറേറ്റിംഗ് സിസ്റ്റം എന്ന് വിളിക്കുന്നു, കൂടാതെ സിസ്റ്റം കൃത്യമായും കാര്യക്ഷമമായും പ്രവർത്തിക്കുന്നുണ്ടോയെന്ന് നിരീക്ഷിക്കുന്നതും ഈ സിസ്റ്റത്തിന്റെ മാനേജ്‌മെന്റ് എളുപ്പം ഉറപ്പാക്കുന്നതും അതിന്റെ ചുമതലകളിൽ ഉൾപ്പെടുന്നു.

ഓപ്പറേറ്റിംഗ് സിസ്റ്റം

OS എന്ന് ചുരുക്കി വിളിക്കപ്പെടുന്ന ഓപ്പറേറ്റിംഗ് സിസ്റ്റം, കമ്പ്യൂട്ടർ ഉറവിടങ്ങൾ കൈകാര്യം ചെയ്യുന്നതിനും കമ്പ്യൂട്ടറുമായുള്ള ഉപയോക്തൃ ഇടപെടൽ സംഘടിപ്പിക്കുന്നതിനുമായി രൂപകൽപ്പന ചെയ്തിട്ടുള്ള പരസ്പരബന്ധിത പ്രോഗ്രാമുകളുടെ ഒരു കൂട്ടമാണ്..
OS അതിന്റെ ഫലപ്രാപ്തി കൈവരിക്കുന്നത് പ്രാഥമികമായി ഏറ്റവും പ്രധാനപ്പെട്ട സാങ്കേതികതയിലൂടെയാണ് - സാങ്കേതികവിദ്യ വെർച്വലൈസേഷൻ. OS ഒരു ഫിസിക്കൽ റിസോഴ്സുമായി (പ്രോസസർ, മെമ്മറി, ഡിസ്ക് മുതലായവ) സംവദിക്കുകയും അതിനെ കൂടുതൽ പൊതുവായതും കൂടുതൽ കഴിവുള്ളതും ഉപയോഗിക്കാൻ എളുപ്പമുള്ളതുമായ രൂപമാക്കി മാറ്റുകയും ചെയ്യുന്നു. അതിനാൽ, ഒരു പൊതു ധാരണയ്ക്കായി, നിങ്ങൾക്ക് ഒരു ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തെ ഒരു വെർച്വൽ മെഷീനുമായി താരതമ്യം ചെയ്യാം.
ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിന് കമാൻഡുകൾ നൽകാനും വിർച്ച്വൽ മെഷീന്റെ കഴിവുകൾ ഉപയോഗിക്കാനും ഉപയോക്താക്കളെ അനുവദിക്കുന്നതിന് (ഒരു പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കുക, മെമ്മറി അനുവദിക്കുക, ഒരു ഫയൽ ആക്‌സസ് ചെയ്യുക തുടങ്ങിയവ), ഓപ്പറേറ്റിംഗ് സിസ്റ്റം ഒരു ഇന്റർഫേസ് നൽകുന്നു എപിഐ (ആപ്ലിക്കേഷൻ പ്രോഗ്രാമിംഗ് ഇന്റർഫേസ്) കൂടാതെ ഏത് കോളുകൾ വിളിക്കാം. ഒരു സാധാരണ ഓപ്പറേറ്റിംഗ് സിസ്റ്റം നൂറുകണക്കിന് സിസ്റ്റം കോളുകൾ ചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുന്നു.
അവസാനമായി, വെർച്വലൈസേഷൻ ഒന്നിലധികം പ്രോഗ്രാമുകൾ പ്രവർത്തിപ്പിക്കാൻ അനുവദിക്കുന്നതിനാൽ (അങ്ങനെ സിപിയു പങ്കിടുന്നു), ഒരേസമയം അവയുടെ നിർദ്ദേശങ്ങളും ഡാറ്റയും ആക്‌സസ് ചെയ്യാനും (അങ്ങനെ മെമ്മറി പങ്കിടുന്നു), ഡിസ്‌കുകൾ ആക്‌സസ് ചെയ്യാനും (അങ്ങനെ I/O ഉപകരണങ്ങൾ പങ്കിടുന്നു) ), ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തെ ഒരു റിസോഴ്‌സ് എന്നും വിളിക്കുന്നു. മാനേജർ. ഓരോ പ്രോസസറും ഡിസ്കും മെമ്മറിയും സിസ്റ്റത്തിന്റെ ഒരു ഉറവിടമാണ്, അതിനാൽ ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിന്റെ റോളുകളിൽ ഒന്ന് ഈ ഉറവിടങ്ങൾ കൈകാര്യം ചെയ്യുന്നതിന്റെ ചുമതലയായി മാറുന്നു, അത് കാര്യക്ഷമമായും ന്യായമായും അല്ലെങ്കിൽ നേരെമറിച്ച്, ഓപ്പറേറ്റിംഗ് സിസ്റ്റം ഏത് ചുമതലയെ ആശ്രയിച്ചിരിക്കുന്നു. രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത്.

സിപിയു വിർച്ച്വലൈസേഷൻ

ഇനിപ്പറയുന്ന പ്രോഗ്രാം പരിഗണിക്കുക:
(https://www.youtube.com/watch?v=zDwT5fUcki4&feature=youtu.be)

ഇത് പ്രത്യേക പ്രവർത്തനങ്ങളൊന്നും ചെയ്യുന്നില്ല; വാസ്തവത്തിൽ, ഇത് ചെയ്യുന്നത് ഒരു ഫംഗ്ഷൻ എന്ന് വിളിക്കുക മാത്രമാണ് സ്പിൻ(), ചാക്രികമായി സമയം പരിശോധിച്ച് ഒരു സെക്കൻഡ് കഴിഞ്ഞതിന് ശേഷം മടങ്ങുക എന്നതാണ് ഇതിന്റെ ചുമതല. അങ്ങനെ, ഉപയോക്താവ് ഒരു ആർഗ്യുമെന്റായി പാസ്സാക്കിയ സ്ട്രിംഗ് അത് അനന്തമായി ആവർത്തിക്കുന്നു.
നമുക്ക് ഈ പ്രോഗ്രാം റൺ ചെയ്ത് ഒരു ആർഗ്യുമെന്റായി "A" എന്ന ചിഹ്നം നൽകാം. ഫലം പ്രത്യേകിച്ച് രസകരമല്ല - സ്ക്രീനിൽ "A" എന്ന ചിഹ്നം ഇടയ്ക്കിടെ പ്രദർശിപ്പിക്കുന്ന ഒരു പ്രോഗ്രാം സിസ്റ്റം ലളിതമായി നടപ്പിലാക്കുന്നു.
ഒരേ പ്രോഗ്രാമിന്റെ നിരവധി സന്ദർഭങ്ങൾ സമാരംഭിക്കുമ്പോൾ, എന്നാൽ വ്യത്യസ്ത അക്ഷരങ്ങൾ പ്രദർശിപ്പിക്കുമ്പോൾ, അത് വ്യക്തമാക്കുന്ന ഓപ്ഷൻ പരീക്ഷിക്കാം. ഈ സാഹചര്യത്തിൽ, ഫലം അല്പം വ്യത്യസ്തമായിരിക്കും. ഞങ്ങൾക്ക് ഒരു പ്രോസസ്സർ ഉണ്ടെങ്കിലും, പ്രോഗ്രാം ഒരേസമയം പ്രവർത്തിക്കുന്നു. ഇത് എങ്ങനെ സംഭവിക്കുന്നു? എന്നാൽ ഹാർഡ്‌വെയർ കഴിവുകളുടെ സഹായമില്ലാതെ ഓപ്പറേറ്റിംഗ് സിസ്റ്റം ഒരു മിഥ്യ സൃഷ്ടിക്കുന്നുവെന്ന് ഇത് മാറുന്നു. ഒരു സിസ്റ്റത്തിൽ ഒന്നിലധികം വെർച്വൽ പ്രോസസ്സറുകൾ ഉണ്ടെന്ന മിഥ്യാധാരണ, ഒരു ഫിസിക്കൽ പ്രോസസറിനെ സൈദ്ധാന്തികമായി അനന്തമായ സംഖ്യയാക്കി മാറ്റുകയും അതുവഴി പ്രോഗ്രാമുകൾ ഒരേസമയം പ്രവർത്തിക്കാൻ അനുവദിക്കുകയും ചെയ്യുന്നു. ഈ മിഥ്യയെ വിളിക്കുന്നു സിപിയു വിർച്ച്വലൈസേഷൻ.
ഈ ചിത്രം നിരവധി ചോദ്യങ്ങൾ ഉയർത്തുന്നു, ഉദാഹരണത്തിന്, ഒരേ സമയം നിരവധി പ്രോഗ്രാമുകൾ പ്രവർത്തിപ്പിക്കണമെങ്കിൽ, ഏതാണ് സമാരംഭിക്കുക? OS "നയങ്ങൾ" ഈ പ്രശ്നത്തിന് ഉത്തരവാദികളാണ്. OS-ൽ പല സ്ഥലങ്ങളിലും നയങ്ങൾ ഉപയോഗിക്കുകയും ഇതുപോലുള്ള ചോദ്യങ്ങൾക്ക് ഉത്തരം നൽകുകയും ചെയ്യുന്നു, കൂടാതെ OS നടപ്പിലാക്കുന്ന അടിസ്ഥാന സംവിധാനങ്ങളും. അതിനാൽ ഒരു റിസോഴ്സ് മാനേജർ എന്ന നിലയിൽ OS-ന്റെ പങ്ക്.

മെമ്മറി വെർച്വലൈസേഷൻ

ഇനി നമുക്ക് മെമ്മറി നോക്കാം. ആധുനിക സിസ്റ്റങ്ങളിലെ മെമ്മറിയുടെ ഭൗതിക മാതൃക ഒരു ബൈറ്റ് അറേ ആയി പ്രതിനിധീകരിക്കുന്നു. മെമ്മറിയിൽ നിന്ന് വായിക്കാൻ നിങ്ങൾ വ്യക്തമാക്കേണ്ടതുണ്ട് സെൽ വിലാസംഅത് ആക്സസ് ചെയ്യാൻ. ഡാറ്റ എഴുതുന്നതിനോ അപ്ഡേറ്റ് ചെയ്യുന്നതിനോ, അത് എഴുതേണ്ട സെല്ലിന്റെ ഡാറ്റയും വിലാസവും നിങ്ങൾ വ്യക്തമാക്കണം.
പ്രോഗ്രാം എക്സിക്യൂഷൻ സമയത്ത് മെമ്മറി ആക്സസ് നിരന്തരം സംഭവിക്കുന്നു. ഒരു പ്രോഗ്രാം അതിന്റെ മുഴുവൻ ഡാറ്റാ ഘടനയും മെമ്മറിയിൽ സംഭരിക്കുകയും വിവിധ നിർദ്ദേശങ്ങൾ നടപ്പിലാക്കുന്നതിലൂടെ അത് ആക്സസ് ചെയ്യുകയും ചെയ്യുന്നു. അതേസമയം, നിർദ്ദേശങ്ങളും മെമ്മറിയിൽ സൂക്ഷിക്കുന്നു, അതിനാൽ അടുത്ത നിർദ്ദേശങ്ങൾക്കായുള്ള ഓരോ അഭ്യർത്ഥനയ്ക്കും ഇത് ആക്സസ് ചെയ്യപ്പെടും.

malloc() എന്ന് വിളിക്കുന്നു

കോൾ ഉപയോഗിച്ച് മെമ്മറിയുടെ ഒരു പ്രദേശം അനുവദിക്കുന്ന ഇനിപ്പറയുന്ന പ്രോഗ്രാം പരിഗണിക്കുക malloc () (https://youtu.be/jnlKRnoT1m0):

പ്രോഗ്രാം നിരവധി കാര്യങ്ങൾ ചെയ്യുന്നു. ആദ്യം, ഇത് കുറച്ച് മെമ്മറി (ലൈൻ 7) അനുവദിക്കുന്നു, തുടർന്ന് അനുവദിച്ച സെല്ലിന്റെ വിലാസം പ്രിന്റ് ചെയ്യുന്നു (ലൈൻ 9), അനുവദിച്ച മെമ്മറിയുടെ ആദ്യ സ്ലോട്ടിലേക്ക് പൂജ്യം എഴുതുന്നു. അടുത്തതായി, പ്രോഗ്രാം ഒരു ലൂപ്പിലേക്ക് പ്രവേശിക്കുന്നു, അതിൽ "p" എന്ന വേരിയബിളിലെ വിലാസത്തിൽ മെമ്മറിയിൽ സംഭരിച്ചിരിക്കുന്ന മൂല്യം വർദ്ധിപ്പിക്കുന്നു. ഇത് സ്വയം പ്രോസസ്സ് ഐഡിയും പ്രദർശിപ്പിക്കുന്നു. ഓരോ റണ്ണിംഗ് പ്രോസസിനും പ്രോസസ് ഐഡി അദ്വിതീയമാണ്. നിരവധി പകർപ്പുകൾ സമാരംഭിച്ച ശേഷം, ഞങ്ങൾ രസകരമായ ഒരു ഫലം കാണും: ആദ്യ സന്ദർഭത്തിൽ, ഞങ്ങൾ ഒന്നും ചെയ്യാതെ നിരവധി പകർപ്പുകൾ സമാരംഭിച്ചാൽ, വിലാസങ്ങൾ വ്യത്യസ്തമായിരിക്കും. എന്നാൽ ഇത് നമ്മുടെ സിദ്ധാന്തത്തിന് കീഴിലല്ല! ശരിയാണ്, കാരണം ആധുനിക വിതരണങ്ങളിൽ ഡിഫോൾട്ടായി മെമ്മറി റാൻഡമൈസേഷൻ പ്രവർത്തനക്ഷമമാക്കിയിട്ടുണ്ട്. നിങ്ങൾ ഇത് പ്രവർത്തനരഹിതമാക്കുകയാണെങ്കിൽ, ഞങ്ങൾക്ക് പ്രതീക്ഷിച്ച ഫലം ലഭിക്കും - ഒരേസമയം പ്രവർത്തിക്കുന്ന രണ്ട് പ്രോഗ്രാമുകളുടെ മെമ്മറി വിലാസങ്ങൾ ഒത്തുചേരും.

രണ്ട് സ്വതന്ത്ര പ്രോഗ്രാമുകൾ അവരുടേതായ സ്വകാര്യ വിലാസ സ്പെയ്സുകളിൽ പ്രവർത്തിക്കുന്നു എന്നതാണ് ഫലം, അത് ഫിസിക്കൽ മെമ്മറിയിൽ ഓപ്പറേറ്റിംഗ് സിസ്റ്റം മാപ്പ് ചെയ്യുന്നു.. അതിനാൽ, ഒരു പ്രോഗ്രാമിനുള്ളിലെ മെമ്മറി വിലാസങ്ങളുടെ ഉപയോഗം മറ്റുള്ളവരെ ഒരു തരത്തിലും ബാധിക്കില്ല, കൂടാതെ ഓരോ പ്രോഗ്രാമിനും അതിന്റേതായ ഫിസിക്കൽ മെമ്മറി ഉണ്ടെന്ന് തോന്നുന്നു, പൂർണ്ണമായും അതിന്റെ വിനിയോഗത്തിൽ. എന്നിരുന്നാലും, ഫിസിക്കൽ മെമ്മറി എന്നത് ഓപ്പറേറ്റിംഗ് സിസ്റ്റം നിയന്ത്രിക്കുന്ന ഒരു പങ്കിട്ട വിഭവമാണ് എന്നതാണ് യാഥാർത്ഥ്യം.

സ്ഥിരത

ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിനുള്ളിലെ മറ്റൊരു പ്രധാന വിഷയം സ്ഥിരത. ഒരൊറ്റ പ്രോഗ്രാമിനുള്ളിൽ ഒരേസമയം പല കാര്യങ്ങളുമായി പ്രവർത്തിക്കുമ്പോൾ സംഭവിക്കാവുന്ന സിസ്റ്റം പ്രശ്നങ്ങളെക്കുറിച്ച് സംസാരിക്കുമ്പോൾ ഈ പദം ഉപയോഗിക്കുന്നു. ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിൽ തന്നെ സ്ഥിരത പ്രശ്നങ്ങൾ ഉണ്ടാകുന്നു. മെമ്മറിയും പ്രോസസർ വിർച്ച്വലൈസേഷനും ഉള്ള മുൻ ഉദാഹരണങ്ങളിൽ, OS ഒരേ സമയം പല കാര്യങ്ങളും കൈകാര്യം ചെയ്യുന്നുവെന്ന് ഞങ്ങൾ മനസ്സിലാക്കി - ആദ്യ പ്രോസസ്സ് സമാരംഭിക്കുന്നു, തുടർന്ന് രണ്ടാമത്തേത് മുതലായവ. ഇത് മാറുന്നതുപോലെ, ഈ സ്വഭാവം ചില പ്രശ്നങ്ങൾക്ക് ഇടയാക്കും. ഉദാഹരണത്തിന്, ആധുനിക മൾട്ടി-ത്രെഡ് പ്രോഗ്രാമുകൾ അത്തരം ബുദ്ധിമുട്ടുകൾ അനുഭവിക്കുന്നു.

ഇനിപ്പറയുന്ന പ്രോഗ്രാം പരിഗണിക്കുക:

പ്രധാന ഫംഗ്ഷനിലെ പ്രോഗ്രാം കോൾ ഉപയോഗിച്ച് രണ്ട് ത്രെഡുകൾ സൃഷ്ടിക്കുന്നു Pthread_create(). ഈ ഉദാഹരണത്തിൽ, മറ്റ് ഫംഗ്‌ഷനുകൾക്ക് അടുത്തായി ഒരേ മെമ്മറി സ്‌പെയ്‌സിൽ പ്രവർത്തിക്കുന്ന ഒരു ഫംഗ്‌ഷനായി ഒരു ത്രെഡ് കണക്കാക്കാം, ഒരേ സമയം ഒന്നിൽ കൂടുതൽ ഫംഗ്‌ഷനുകൾ പ്രവർത്തിക്കുന്നു. ഈ ഉദാഹരണത്തിൽ, ഓരോ ത്രെഡും ഒരു ഫംഗ്ഷൻ ആരംഭിക്കുകയും നിർവ്വഹിക്കുകയും ചെയ്യുന്നു worker() അത് വേരിയബിളിനെ വർദ്ധിപ്പിക്കുന്നു,.

നമുക്ക് ഈ പ്രോഗ്രാം 1000 ആർഗ്യുമെന്റ് ഉപയോഗിച്ച് പ്രവർത്തിപ്പിക്കാം. നിങ്ങൾ ഊഹിച്ചതുപോലെ, ഓരോ ത്രെഡും വേരിയബിളിനെ 2000 മടങ്ങ് വർദ്ധിപ്പിക്കുന്നതിനാൽ, ഫലം 1000 ആയിരിക്കണം. എന്നിരുന്നാലും, എല്ലാം അത്ര ലളിതമല്ല. കൂടുതൽ ആവർത്തനങ്ങളുടെ ക്രമത്തിൽ പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കാൻ ശ്രമിക്കാം.

ഒരു നമ്പർ ഇൻപുട്ട് ചെയ്യുന്നതിലൂടെ, ഉദാഹരണത്തിന്, 100000, ഔട്ട്‌പുട്ടിൽ 200000 എന്ന സംഖ്യ കാണാൻ ഞങ്ങൾ പ്രതീക്ഷിക്കുന്നു. എന്നിരുന്നാലും, 100000 എന്ന നമ്പർ നിരവധി തവണ പ്രവർത്തിപ്പിക്കുന്നതിലൂടെ, ശരിയായ ഉത്തരം കാണാനാകില്ല, മാത്രമല്ല വ്യത്യസ്തമായ തെറ്റായ ഉത്തരങ്ങളും ലഭിക്കും. ഒരു നമ്പർ വർദ്ധിപ്പിക്കുന്നതിന് മൂന്ന് പ്രവർത്തനങ്ങൾ ആവശ്യമാണ് എന്ന വസ്തുതയിലാണ് ഉത്തരം സ്ഥിതിചെയ്യുന്നത് - മെമ്മറിയിൽ നിന്ന് നമ്പർ വീണ്ടെടുക്കുക, അത് വർദ്ധിപ്പിക്കുക, തുടർന്ന് നമ്പർ തിരികെ എഴുതുക. ഈ നിർദ്ദേശങ്ങളെല്ലാം ആറ്റോമിക് ആയി നടപ്പിലാക്കാത്തതിനാൽ (എല്ലാം ഒരേ സമയം), ഇതുപോലുള്ള വിചിത്രമായ കാര്യങ്ങൾ സംഭവിക്കാം. പ്രോഗ്രാമിംഗിൽ ഈ പ്രശ്നത്തെ വിളിക്കുന്നു ജാതി അവസ്ഥ - റേസ് അവസ്ഥ. അജ്ഞാത നിമിഷത്തിൽ അജ്ഞാത ശക്തികൾ നിങ്ങളുടെ ഏതെങ്കിലും പ്രവർത്തനങ്ങളുടെ നിർവ്വഹണത്തെ ബാധിക്കുമ്പോൾ.

അവലംബം: www.habr.com