നല്ല ഫിലോസഫർ അല്ലെങ്കിൽ മത്സരാധിഷ്ഠിത .NET പ്രോഗ്രാമിംഗ്

ഉച്ചഭക്ഷണ തത്ത്വചിന്തകരുടെ പ്രശ്നത്തിൻ്റെ ഉദാഹരണം ഉപയോഗിച്ച് .നെറ്റിൽ സമാന്തരവും സമാന്തരവുമായ പ്രോഗ്രാമിംഗ് എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് നോക്കാം. ത്രെഡ്/പ്രോസസ് സിൻക്രൊണൈസേഷൻ മുതൽ ആക്ടർ മോഡൽ വരെ (ഇനിപ്പറയുന്ന ഭാഗങ്ങളിൽ) പ്ലാൻ ഇപ്രകാരമാണ്. ആദ്യ പരിചയക്കാരനോ നിങ്ങളുടെ അറിവ് പുതുക്കുന്നതിനോ ലേഖനം ഉപയോഗപ്രദമാകും.

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

ലക്ഷ്യം

Edsger Dijkstra 1965-ൽ തൻ്റെ വിദ്യാർത്ഥികളോട് ഈ പ്രശ്നം ചോദിച്ചു. സ്ഥാപിതമായ രൂപീകരണം ഇപ്രകാരമാണ്. ഒരു നിശ്ചിത (സാധാരണയായി അഞ്ച്) തത്ത്വചിന്തകരും അതേ എണ്ണം ഫോർക്കുകളും ഉണ്ട്. അവർ ഒരു റൗണ്ട് ടേബിളിൽ ഇരിക്കുന്നു, അവയ്ക്കിടയിൽ ഫോർക്കുകൾ. തത്ത്വചിന്തകർക്ക് അനന്തമായ ഭക്ഷണത്തിൻ്റെ പ്ലേറ്റുകളിൽ നിന്ന് കഴിക്കാം, ചിന്തിക്കാം അല്ലെങ്കിൽ കാത്തിരിക്കാം. ഭക്ഷണം കഴിക്കാൻ, ഒരു തത്ത്വചിന്തകൻ രണ്ട് ഫോർക്കുകൾ എടുക്കേണ്ടതുണ്ട് (രണ്ടാമത്തേത് മുമ്പത്തേതിനൊപ്പം ഒരു ഫോർക്ക് പങ്കിടുന്നു). ഒരു ഫോർക്ക് എടുക്കുന്നതും താഴെയിടുന്നതും രണ്ട് വ്യത്യസ്ത പ്രവർത്തനങ്ങളാണ്. എല്ലാ തത്ത്വചിന്തകരും നിശബ്ദരാണ്. 54 വർഷത്തിനു ശേഷവും അവരെല്ലാം ചിന്തിക്കുകയും നന്നായി ഭക്ഷണം നൽകുകയും ചെയ്യുന്ന തരത്തിൽ അത്തരമൊരു അൽഗോരിതം കണ്ടെത്തുക എന്നതാണ് ചുമതല.

ആദ്യം, പങ്കിട്ട ഇടം ഉപയോഗിച്ച് ഈ പ്രശ്നം പരിഹരിക്കാൻ ശ്രമിക്കാം. നാൽക്കവലകൾ സാധാരണ മേശപ്പുറത്ത് കിടക്കുന്നു, തത്ത്വചിന്തകർ അവ അവിടെയുള്ളപ്പോൾ എടുത്ത് തിരികെ വയ്ക്കുക. ഇവിടെയാണ് സിൻക്രൊണൈസേഷനുമായി ബന്ധപ്പെട്ട പ്രശ്നങ്ങൾ ഉണ്ടാകുന്നത്, കൃത്യമായി എപ്പോഴാണ് ഫോർക്കുകൾ എടുക്കേണ്ടത്? പ്ലഗ് ഇല്ലെങ്കിൽ എന്തുചെയ്യും? മുതലായവ. എന്നാൽ ആദ്യം, നമുക്ക് തത്ത്വചിന്തകരിൽ നിന്ന് ആരംഭിക്കാം.

ത്രെഡുകൾ ആരംഭിക്കുന്നതിന് ഞങ്ങൾ വഴി ഒരു ത്രെഡ് പൂൾ ഉപയോഗിക്കുന്നു Task.Run രീതി:

var cancelTokenSource = new CancellationTokenSource();
Action<int> create = (i) => RunPhilosopher(i, cancelTokenSource.Token);
for (int i = 0; i < philosophersAmount; i++) 
{
    int icopy = i;
    // Поместить задачу в очередь пула потоков. Метод RunDeadlock не запускаеться 
    // сразу, а ждет своего потока. Асинхронный запуск.
    philosophers[i] = Task.Run(() => create(icopy), cancelTokenSource.Token);
}

ത്രെഡുകൾ സൃഷ്ടിക്കുന്നതും നീക്കംചെയ്യുന്നതും ഒപ്റ്റിമൈസ് ചെയ്യുന്നതിനാണ് ത്രെഡ് പൂൾ രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത്. ഈ പൂളിന് ടാസ്‌ക്കുകളുടെ ഒരു ക്യൂ ഉണ്ട്, ഈ ടാസ്‌ക്കുകളുടെ എണ്ണം അനുസരിച്ച് CLR ത്രെഡുകൾ സൃഷ്‌ടിക്കുകയോ ഇല്ലാതാക്കുകയോ ചെയ്യുന്നു. എല്ലാ AppDomains-നും ഒരു പൂൾ. ഈ കുളം മിക്കവാറും എപ്പോഴും ഉപയോഗിക്കേണ്ടതാണ്, കാരണം... ത്രെഡുകൾ, അവയുടെ ക്യൂകൾ മുതലായവ സൃഷ്‌ടിക്കുന്നതിനും ഇല്ലാതാക്കുന്നതിനും വിഷമിക്കേണ്ടതില്ല. നിങ്ങൾക്ക് ഇത് ഒരു പൂൾ ഇല്ലാതെ തന്നെ ചെയ്യാം, എന്നാൽ നിങ്ങൾ അത് നേരിട്ട് ഉപയോഗിക്കേണ്ടിവരും Thread, ഒരു ത്രെഡിൻ്റെ മുൻഗണന മാറ്റേണ്ട സന്ദർഭങ്ങളിൽ, ഞങ്ങൾക്ക് ഒരു നീണ്ട പ്രവർത്തനമുള്ളപ്പോൾ, ഒരു ഫോർഗ്രൗണ്ട് ത്രെഡിനായി ഇത് ഉപയോഗപ്രദമാണ്.

മറ്റൊരു വാക്കിൽ, System.Threading.Tasks.Task ക്ലാസ് തന്നെ Thread, എന്നാൽ എല്ലാത്തരം സൗകര്യങ്ങളോടും കൂടി: മറ്റ് ടാസ്‌ക്കുകളുടെ ഒരു ബ്ലോക്കിന് ശേഷം ഒരു ടാസ്‌ക്ക് സമാരംഭിക്കാനുള്ള കഴിവ്, ഫംഗ്ഷനുകളിൽ നിന്ന് അവ തിരികെ നൽകുക, സൗകര്യപൂർവ്വം തടസ്സപ്പെടുത്തുക, കൂടാതെ മറ്റു പലതും. മുതലായവ. അസിൻക്/വെയ്റ്റ് കൺസ്ട്രക്ഷൻസ് (ടാസ്ക് അടിസ്ഥാനമാക്കിയുള്ള അസിൻക്രണസ് പാറ്റേൺ, ഐഒ ഓപ്പറേഷനുകൾക്കായി കാത്തിരിക്കുന്നതിനുള്ള വാക്യഘടന പഞ്ചസാര) പിന്തുണയ്ക്കുന്നതിന് അവ ആവശ്യമാണ്. ഇതിനെക്കുറിച്ച് പിന്നീട് സംസാരിക്കാം.

CancelationTokenSource കോളിംഗ് ത്രെഡിൽ നിന്നുള്ള ഒരു സിഗ്നലിൽ ത്രെഡ് സ്വയം അവസാനിപ്പിക്കാൻ ഇവിടെ അത് ആവശ്യമാണ്.

സമന്വയ പ്രശ്നങ്ങൾ

തത്ത്വചിന്തകരെ തടഞ്ഞു

ശരി, ത്രെഡുകൾ എങ്ങനെ സൃഷ്ടിക്കാമെന്ന് ഞങ്ങൾക്കറിയാം, ഉച്ചഭക്ഷണം പരീക്ഷിക്കാം:

// Кто какие вилки взял. К примеру: 1 1 3 3 - 1й и 3й взяли первые две пары.
private int[] forks = Enumerable.Repeat(0, philosophersAmount).ToArray();

// То же, что RunPhilosopher()
private void RunDeadlock(int i, CancellationToken token) 
{
    // Ждать вилку, взять её. Эквивалентно: 
    // while(true) 
    //     if forks[fork] == 0 
    //          forks[fork] = i+1
    //          break
    //     Thread.Sleep() или Yield() или SpinWait()
    void TakeFork(int fork) =>
        SpinWait.SpinUntil(() => 
            Interlocked.CompareExchange(ref forks[fork], i+1, 0) == 0);

    // Для простоты, но можно с Interlocked.Exchange:
    void PutFork(int fork) => forks[fork] = 0;

    while (true)
    {
        TakeFork(Left(i));
        TakeFork(Right(i));
        eatenFood[i] = (eatenFood[i] + 1) % (int.MaxValue - 1);
        PutFork(Left(i));
        PutFork(Right(i));
        Think(i);

        // Завершить работу по-хорошему.
        token.ThrowIfCancellationRequested();
    }
}

ഇവിടെ നമ്മൾ ആദ്യം ഇടത്തേയും പിന്നീട് വലത്തേയും ഫോർക്ക് എടുക്കാൻ ശ്രമിക്കുന്നു, അത് പ്രവർത്തിക്കുന്നുണ്ടെങ്കിൽ, ഞങ്ങൾ ഭക്ഷണം കഴിച്ച് തിരികെ വയ്ക്കുക. ഒരു ഫോർക്ക് എടുക്കുന്നത് ആറ്റോമിക് ആണ്, അതായത്. രണ്ട് ത്രെഡുകൾക്ക് ഒരേ സമയം ഒരെണ്ണം എടുക്കാൻ കഴിയില്ല (തെറ്റ്: ഫോർക്ക് സൗജന്യമാണെന്ന് ആദ്യത്തേത് വായിക്കുന്നു, രണ്ടാമത്തേത് അത് ചെയ്യുന്നു, ആദ്യത്തേത് എടുക്കുന്നു, രണ്ടാമത്തേത് എടുക്കുന്നു). ഇതിനായി Interlocked.CompareExchange, ഇത് ഒരു പ്രൊസസർ നിർദ്ദേശം ഉപയോഗിച്ച് നടപ്പിലാക്കണം (TSL, XCHG), ആറ്റോമിക് സീക്വൻഷ്യൽ റീഡിംഗിനും റൈറ്റിംഗിനും വേണ്ടിയുള്ള മെമ്മറിയുടെ ഒരു ഭാഗം ലോക്ക് ചെയ്യുന്നു. ഒപ്പം SpinWait നിർമ്മാണത്തിന് തുല്യമാണ് while(true) ഒരു ചെറിയ "മാജിക്" ഉപയോഗിച്ച് മാത്രം - ത്രെഡ് പ്രോസസ്സർ എടുക്കുന്നു (Thread.SpinWait), എന്നാൽ ചിലപ്പോൾ മറ്റൊരു ത്രെഡിലേക്ക് നിയന്ത്രണം കൈമാറുന്നു (Thread.Yeild) അല്ലെങ്കിൽ ഉറങ്ങുന്നു (Thread.Sleep).

എന്നാൽ ഈ പരിഹാരം പ്രവർത്തിക്കുന്നില്ല, കാരണം ... ത്രെഡുകൾ ഉടൻ (എനിക്ക് ഒരു സെക്കൻഡിനുള്ളിൽ) തടഞ്ഞു: എല്ലാ തത്ത്വചിന്തകരും അവരുടെ ഇടത് നാൽക്കവല എടുക്കുന്നു, പക്ഷേ ശരിയായ ഒന്നുമില്ല. ഫോർക്ക് അറേയ്‌ക്ക് അപ്പോൾ മൂല്യങ്ങളുണ്ട്: 1 2 3 4 5.

ചിത്രത്തിൽ, ത്രെഡുകൾ തടയുന്നു (ഡെഡ്ലോക്ക്). പച്ച നിർവ്വഹണത്തെ സൂചിപ്പിക്കുന്നു, ചുവപ്പ് സമന്വയത്തെ സൂചിപ്പിക്കുന്നു, ചാരനിറം ത്രെഡ് ഉറങ്ങുകയാണെന്ന് സൂചിപ്പിക്കുന്നു. വജ്രങ്ങൾ ടാസ്‌ക്കുകളുടെ വിക്ഷേപണ സമയത്തെ സൂചിപ്പിക്കുന്നു.

ദാർശനികരുടെ വിശപ്പ്

നിങ്ങൾക്ക് ചിന്തിക്കാൻ ധാരാളം ഭക്ഷണം ആവശ്യമില്ലെങ്കിലും, വിശപ്പ് തത്ത്വചിന്ത ഉപേക്ഷിക്കാൻ ആരെയും പ്രേരിപ്പിക്കും. നമ്മുടെ പ്രശ്നത്തിൽ ത്രെഡ് പട്ടിണിയുടെ സാഹചര്യം അനുകരിക്കാൻ ശ്രമിക്കാം. ഒരു ത്രെഡ് പ്രവർത്തിക്കുമ്പോൾ, പക്ഷേ കാര്യമായ ജോലിയില്ലാതെ, മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, ഇത് അതേ തടസ്സമാണ്, ഇപ്പോൾ ത്രെഡ് ഉറങ്ങുന്നില്ല, പക്ഷേ സജീവമായി എന്തെങ്കിലും കഴിക്കാൻ നോക്കുന്നു, പക്ഷേ ഭക്ഷണമില്ല. ഇടയ്‌ക്കിടെ തടയുന്നത് ഒഴിവാക്കാൻ, മറ്റൊന്ന് എടുക്കാൻ കഴിയുന്നില്ലെങ്കിൽ ഞങ്ങൾ ഫോർക്ക് തിരികെ ഇടും.

// То же что и в RunDeadlock, но теперь кладем вилку назад и добавляем плохих философов.
private void RunStarvation(int i, CancellationToken token)
{
    while (true)
    {
        bool hasTwoForks = false;
        var waitTime = TimeSpan.FromMilliseconds(50);
        // Плохой философов может уже иметь вилку:
        bool hasLeft = forks[Left(i)] == i + 1;
        if (hasLeft || TakeFork(Left(i), i + 1, waitTime))
        {
            if (TakeFork(Right(i), i + 1, TimeSpan.Zero))
                hasTwoForks = true;
            else
                PutFork(Left(i)); // Иногда плохой философ отдает вилку назад.
        } 
        if (!hasTwoForks)
        {
            if (token.IsCancellationRequested) break;
            continue;
        }
        eatenFood[i] = (eatenFood[i] + 1) % (int.MaxValue - 1);
        bool goodPhilosopher = i % 2 == 0;
        // А плохой философ забывает положить свою вилку обратно:
        if (goodPhilosopher)
            PutFork(Left(i));
        // А если и правую не положит, то хорошие будут вообще без еды.
        PutFork(Right(i));

        Think(i);

        if (token.IsCancellationRequested)
            break;
    }
}

// Теперь можно ждать определенное время.
bool TakeFork(int fork, int philosopher, TimeSpan? waitTime = null)
{
    return SpinWait.SpinUntil(
        () => Interlocked.CompareExchange(ref forks[fork], philosopher, 0) == 0,
              waitTime ?? TimeSpan.FromMilliseconds(-1)
    );
}

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

ത്രെഡുകൾ ചിലപ്പോൾ ഉണർന്ന് ഒരു വിഭവം നേടാൻ ശ്രമിക്കുന്നത് ഇവിടെ നിങ്ങൾക്ക് കാണാൻ കഴിയും. നാലിൽ രണ്ടെണ്ണം ഒന്നും ചെയ്യുന്നില്ല (മുകളിലുള്ള പച്ച ഗ്രാഫ്).

ഒരു തത്ത്വചിന്തകൻ്റെ മരണം

ശരി, തത്ത്വചിന്തകരുടെ മഹത്തായ അത്താഴത്തെ തടസ്സപ്പെടുത്തുന്ന മറ്റൊരു പ്രശ്നം, അവരിൽ ഒരാൾ പെട്ടെന്ന് കൈകളിൽ നാൽക്കവലയുമായി മരിക്കുകയാണെങ്കിൽ (അയാൾ അങ്ങനെ തന്നെ സംസ്കരിക്കപ്പെടും). അപ്പോൾ അയൽക്കാർ ഉച്ചഭക്ഷണം കഴിക്കാതെ വിടും. ഈ കേസിനായി നിങ്ങൾക്ക് സ്വയം ഒരു ഉദാഹരണ കോഡ് കൊണ്ടുവരാൻ കഴിയും, ഉദാഹരണത്തിന് അത് വലിച്ചെറിയപ്പെടുന്നു NullReferenceException തത്ത്വചിന്തകൻ ഫോർക്കുകൾ എടുത്ത ശേഷം. കൂടാതെ, ഒഴിവാക്കൽ കൈകാര്യം ചെയ്യില്ല കൂടാതെ കോളിംഗ് കോഡ് അത് പിടിക്കുകയുമില്ല (ഇതിനായി AppDomain.CurrentDomain.UnhandledException മുതലായവ). അതിനാൽ, ത്രെഡുകളിൽ തന്നെയും ഭംഗിയുള്ള അവസാനിപ്പിക്കലോടെയും പിശക് കൈകാര്യം ചെയ്യുന്നവർ ആവശ്യമാണ്.

വെയിറ്റർ

ശരി, പ്രതിസന്ധികൾ, പട്ടിണി, മരണങ്ങൾ എന്നിവയുടെ ഈ പ്രശ്നം ഞങ്ങൾ എങ്ങനെ പരിഹരിക്കും? ഫോർക്കുകളിലേക്ക് ഞങ്ങൾ ഒരു തത്ത്വചിന്തകനെ മാത്രമേ അനുവദിക്കൂ, ഈ സ്ഥലത്തിനായി ഞങ്ങൾ ത്രെഡുകളുടെ പരസ്പര ഒഴിവാക്കൽ ചേർക്കും. ഇത് എങ്ങനെ ചെയ്യാം? തത്ത്വചിന്തകരുടെ അടുത്തായി ഒരു തത്ത്വചിന്തകന് ഫോർക്കുകൾ എടുക്കാൻ അനുവാദം നൽകുന്ന ഒരു വെയിറ്റർ ഉണ്ടെന്ന് കരുതുക. ഈ വെയിറ്ററെ എങ്ങനെ ഉണ്ടാക്കണം, തത്ത്വചിന്തകർ അവനോട് എങ്ങനെ ചോദിക്കും എന്നിവ രസകരമായ ചോദ്യങ്ങളാണ്.

തത്ത്വചിന്തകർ ഫോർക്കുകളിലേക്കുള്ള പ്രവേശനത്തിനായി വെയിറ്ററോട് നിരന്തരം ആവശ്യപ്പെടുക എന്നതാണ് ഏറ്റവും ലളിതമായ മാർഗം. ആ. ഇപ്പോൾ തത്ത്വചിന്തകർ അടുത്തുള്ള ഒരു നാൽക്കവലയ്ക്കായി കാത്തിരിക്കില്ല, പക്ഷേ കാത്തിരിക്കുക അല്ലെങ്കിൽ വെയിറ്ററോട് ചോദിക്കുക. ആദ്യം ഞങ്ങൾ ഇതിനായി യൂസർ സ്പേസ് മാത്രമേ ഉപയോഗിക്കുന്നുള്ളൂ;

ഉപയോക്തൃ സ്ഥല പരിഹാരങ്ങൾ

ഒരു നാൽക്കവലയും രണ്ട് തത്ത്വചിന്തകരും ഉപയോഗിച്ച് ഞങ്ങൾ മുമ്പ് ചെയ്ത അതേ കാര്യം ഇവിടെ ഞങ്ങൾ ചെയ്യും, ഞങ്ങൾ ഒരു ലൂപ്പിൽ കറങ്ങി കാത്തിരിക്കും. എന്നാൽ ഇപ്പോൾ അത് എല്ലാ തത്ത്വചിന്തകരും ആയിരിക്കും, അത് പോലെ, ഒരേയൊരു നാൽക്കവല, അതായത്. വെയിറ്ററിൽ നിന്ന് ഈ "സ്വർണ്ണ നാൽക്കവല" എടുത്ത തത്ത്വചിന്തകൻ മാത്രമേ കഴിക്കൂ എന്ന് നമുക്ക് പറയാം. ഇത് ചെയ്യുന്നതിന് ഞങ്ങൾ SpinLock ഉപയോഗിക്കുന്നു.

private static SpinLock spinLock = new SpinLock();  // Наш "официант"
private void RunSpinLock(int i, CancellationToken token)
{
    while (true)
    {
        // Взаимная блокировка через busy waiting. Вызываем до try, чтобы
        // выбрасить исключение в случае ошибки в самом SpinLock.
        bool hasLock = false;
        spinLock.Enter(ref hasLock);
        try
        {
            // Здесь может быть только один поток (mutual exclusion).
            forks[Left(i)] = i + 1;  // Берем вилку сразу, без ожидания.
            forks[Right(i)] = i + 1;
            eatenFood[i] = (eatenFood[i] + 1) % (int.MaxValue - 1);
            forks[Left(i)] = 0;
            forks[Right(i)] = 0;
        }
        finally
        {
            if(hasLock) spinLock.Exit();  // Избегаем проблемы со смертью философа.
        }

        Think(i);

        if (token.IsCancellationRequested)
            break;
    }
}

SpinLock ഇത് ഒരു ബ്ലോക്കറാണ്, ഏകദേശം പറഞ്ഞാൽ, സമാനമാണ് while(true) { if (!lock) break; }, എന്നാൽ ഉള്ളതിനേക്കാൾ കൂടുതൽ "മാജിക്" ഉപയോഗിച്ച് SpinWait (അവിടെ ഉപയോഗിക്കുന്നത്). ഇപ്പോൾ കാത്തിരിക്കുന്നവരെ എങ്ങനെ എണ്ണാമെന്നും അവരെ അൽപ്പം ഉറങ്ങണമെന്നും അതിലേറെ കാര്യങ്ങൾ ചെയ്യാമെന്നും അവനറിയാം. മുതലായവ പൊതുവേ, ഒപ്റ്റിമൈസ് ചെയ്യാൻ സാധ്യമായതെല്ലാം ചെയ്യുന്നു. എന്നാൽ ഇത് ഇപ്പോഴും പ്രോസസർ വിഭവങ്ങൾ തിന്നുകയും ഒരു ത്രെഡ് കൈവശം വയ്ക്കുകയും ചെയ്യുന്ന അതേ സജീവമായ ലൂപ്പാണെന്ന് നാം ഓർക്കണം, തത്ത്വചിന്തകരിൽ ഒരാൾ മറ്റുള്ളവരെ അപേക്ഷിച്ച് കൂടുതൽ മുൻഗണന നൽകിയാൽ പട്ടിണിയിലേക്ക് നയിച്ചേക്കാം, പക്ഷേ ഒരു ഗോൾഡൻ ഫോർക്ക് ഇല്ല (മുൻഗണന വിപരീത പ്രശ്നം ). അതിനാൽ, മൂന്നാം കക്ഷി കോളുകളോ നെസ്റ്റഡ് ലോക്കുകളോ മറ്റ് ആശ്ചര്യങ്ങളോ ഇല്ലാതെ, പങ്കിട്ട മെമ്മറിയിലെ വളരെ ചെറിയ മാറ്റങ്ങൾക്ക് മാത്രമാണ് ഞങ്ങൾ ഇത് ഉപയോഗിക്കുന്നത്.

വേണ്ടി വരയ്ക്കുന്നു SpinLock. സ്ട്രീമുകൾ സുവർണ്ണ നാൽക്കവലയ്ക്കായി നിരന്തരം "പോരാട്ടം" ചെയ്യുന്നു. പരാജയങ്ങൾ സംഭവിക്കുന്നു - ചിത്രത്തിൽ ഹൈലൈറ്റ് ചെയ്ത പ്രദേശം. കോറുകൾ പൂർണ്ണമായി ഉപയോഗിച്ചിട്ടില്ല: ഈ നാല് ത്രെഡുകളാൽ ഏകദേശം 2/3 മാത്രം.

ഇവിടെ മറ്റൊരു പരിഹാരം ഉപയോഗിക്കുന്നത് മാത്രമാണ് Interlocked.CompareExchange മുകളിലെ കോഡിൽ കാണിച്ചിരിക്കുന്ന അതേ സജീവമായ കാത്തിരിപ്പോടെ (പട്ടിണി കിടക്കുന്ന തത്ത്വചിന്തകരിൽ), എന്നാൽ ഇത് ഇതിനകം പറഞ്ഞതുപോലെ, സൈദ്ധാന്തികമായി തടയുന്നതിലേക്ക് നയിച്ചേക്കാം.

ഓൺ Interlocked മാത്രമല്ല ഉള്ളത് എന്ന് പറയേണ്ടതാണ് CompareExchange, മാത്രമല്ല ആറ്റോമിക് വായനയ്ക്കും എഴുത്തിനുമുള്ള മറ്റ് രീതികളും. മാറ്റം ആവർത്തിക്കുന്നതിലൂടെ, മറ്റൊരു ത്രെഡ് അതിൻ്റെ മാറ്റങ്ങൾ വരുത്തിയാൽ (1 വായിക്കുക, 2 വായിക്കുക, 2 എഴുതുക, എഴുതുക 1 മോശമാണ്), ഒരു മൂല്യത്തിലേക്ക് (ഇൻ്റർലോക്ക്ഡ് എനിതിംഗ് പാറ്റേൺ) സങ്കീർണ്ണമായ മാറ്റങ്ങൾക്ക് ഇത് ഉപയോഗിക്കാം.

കേർണൽ മോഡ് പരിഹാരങ്ങൾ

ഒരു ലൂപ്പിൽ വിഭവങ്ങൾ പാഴാക്കാതിരിക്കാൻ, ഒരു ത്രെഡ് എങ്ങനെ തടയാമെന്ന് നോക്കാം. മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, നമ്മുടെ ഉദാഹരണം തുടരുന്നതിലൂടെ, വെയിറ്റർ തത്ത്വചിന്തകനെ എങ്ങനെ ഉറങ്ങുകയും ആവശ്യമുള്ളപ്പോൾ മാത്രം അവനെ ഉണർത്തുകയും ചെയ്യുന്നു എന്ന് നോക്കാം. ആദ്യം, ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിൻ്റെ കേർണൽ മോഡ് വഴി ഇത് എങ്ങനെ ചെയ്യാമെന്ന് നോക്കാം. അവിടെയുള്ള എല്ലാ ഘടനകളും പലപ്പോഴും ഉപയോക്തൃ സ്ഥലത്തേക്കാൾ മന്ദഗതിയിലാണ് അവസാനിക്കുന്നത്. നിരവധി തവണ പതുക്കെ, ഉദാഹരണത്തിന് AutoResetEvent ഒരുപക്ഷേ 53 മടങ്ങ് പതുക്കെ SpinLock [റിക്ടർ]. എന്നാൽ അവരുടെ സഹായത്തോടെ, നിങ്ങൾക്ക് മുഴുവൻ സിസ്റ്റത്തിലുടനീളമുള്ള പ്രക്രിയകൾ സമന്വയിപ്പിക്കാൻ കഴിയും, മാനേജ് ചെയ്താലും അല്ലാതെയും.

അരനൂറ്റാണ്ടിലേറെ മുമ്പ് Dijkstra നിർദ്ദേശിച്ച ഒരു സെമാഫോറാണ് ഇവിടെ അടിസ്ഥാന രൂപകൽപ്പന. ഒരു സെമാഫോർ, ലളിതമായി പറഞ്ഞാൽ, സിസ്റ്റം നിയന്ത്രിക്കുന്ന ഒരു പോസിറ്റീവ് പൂർണ്ണസംഖ്യയാണ്, അതിൽ രണ്ട് പ്രവർത്തനങ്ങൾ - കൂട്ടുകയും കുറയുകയും ചെയ്യുന്നു. പൂജ്യം കുറയ്ക്കാൻ കഴിയുന്നില്ലെങ്കിൽ, കോളിംഗ് ത്രെഡ് തടഞ്ഞു. മറ്റേതെങ്കിലും സജീവമായ ത്രെഡ്/പ്രക്രിയ വഴി സംഖ്യ വർദ്ധിപ്പിക്കുമ്പോൾ, ത്രെഡുകൾ കടന്നുപോകുകയും സെമാഫോർ പാസ്സായ സംഖ്യയാൽ വീണ്ടും കുറയുകയും ചെയ്യുന്നു. സെമാഫോറുള്ള ഒരു കുപ്പിവളയിൽ ട്രെയിനുകളെ നിങ്ങൾക്ക് സങ്കൽപ്പിക്കാൻ കഴിയും. സമാനമായ പ്രവർത്തനക്ഷമതയുള്ള നിരവധി നിർമ്മാണങ്ങൾ .NET വാഗ്ദാനം ചെയ്യുന്നു: AutoResetEvent, ManualResetEvent, Mutex ഞാനും Semaphore. ഞങ്ങൾ ഉപയോഗിക്കും AutoResetEvent, ഈ നിർമ്മാണങ്ങളിൽ ഏറ്റവും ലളിതമായത് ഇതാണ്: 0, 1 എന്നീ രണ്ട് മൂല്യങ്ങൾ മാത്രം (തെറ്റും ശരിയും). അവളുടെ രീതി WaitOne() മൂല്യം 0 ആയിരുന്നെങ്കിൽ കോളിംഗ് ത്രെഡ് തടയുന്നു, 1 ആണെങ്കിൽ, അതിനെ 0 ആയി താഴ്ത്തി അത് ഒഴിവാക്കുന്നു. ഒരു രീതി Set() 1 ആയി വർദ്ധിക്കുകയും ഒരാളെ കടന്നുപോകാൻ അനുവദിക്കുകയും ചെയ്യുന്നു, അത് വീണ്ടും 0 ആയി കുറയുന്നു. സബ്‌വേയിൽ ഒരു ടേൺസ്റ്റൈൽ പോലെ പ്രവർത്തിക്കുന്നു.

നമുക്ക് പരിഹാരം സങ്കീർണ്ണമാക്കുകയും ഓരോ തത്ത്വചിന്തകനും തടയൽ ഉപയോഗിക്കുകയും ചെയ്യാം, അല്ലാതെ ഒറ്റയടിക്ക് അല്ല. ആ. ഇപ്പോൾ നിരവധി തത്ത്വചിന്തകർക്ക് ഒരേസമയം ഭക്ഷണം കഴിക്കാം, ഒന്നല്ല. എന്നാൽ റേസ് സാഹചര്യങ്ങൾ ഒഴിവാക്കിക്കൊണ്ട് ഫോർക്കുകൾ ശരിയായി എടുക്കുന്നതിന് ഞങ്ങൾ വീണ്ടും പട്ടികയിലേക്കുള്ള ആക്സസ് തടയുന്നു.

// Для блокирования отдельного философа.
// Инициализируется: new AutoResetEvent(true) для каждого.
private AutoResetEvent[] philosopherEvents;

// Для доступа к вилкам / доступ к столу.
private AutoResetEvent tableEvent = new AutoResetEvent(true);

// Рождение философа.
public void Run(int i, CancellationToken token)
{
    while (true)
    {
        TakeForks(i); // Ждет вилки.
        // Обед. Может быть и дольше.
        eatenFood[i] = (eatenFood[i] + 1) % (int.MaxValue - 1);
        PutForks(i); // Отдать вилки и разблокировать соседей.
        Think(i);
        if (token.IsCancellationRequested) break;
    }
}

// Ожидать вилки в блокировке.
void TakeForks(int i)
{
    bool hasForks = false;
    while (!hasForks) // Попробовать еще раз (блокировка не здесь).
    {
        // Исключающий доступ к столу, без гонок за вилками.
        tableEvent.WaitOne();
        if (forks[Left(i)] == 0 && forks[Right(i)] == 0)
            forks[Left(i)] = forks[Right(i)] = i + 1;
        hasForks = forks[Left(i)] == i + 1 && forks[Right(i)] == i + 1;
        if (hasForks)
            // Теперь философ поест, выйдет из цикла. Если Set 
            // вызван дважды, то значение true.
            philosopherEvents[i].Set();
        // Разблокировать одного ожидающего. После него значение tableEvent в false.
        tableEvent.Set(); 
        // Если имеет true, не блокируется, а если false, то будет ждать Set от соседа.
        philosopherEvents[i].WaitOne();
    }
}

// Отдать вилки и разблокировать соседей.
void PutForks(int i)
{
    tableEvent.WaitOne(); // Без гонок за вилками.
    forks[Left(i)] = 0;
    // Пробудить левого, а потом и правого соседа, либо AutoResetEvent в true.
    philosopherEvents[LeftPhilosopher(i)].Set();
    forks[Right(i)] = 0;
    philosopherEvents[RightPhilosopher(i)].Set();
    tableEvent.Set();
}

ഇവിടെ എന്താണ് സംഭവിക്കുന്നതെന്ന് മനസിലാക്കാൻ, തത്ത്വചിന്തകൻ ഫോർക്കുകൾ എടുക്കുന്നതിൽ പരാജയപ്പെട്ടപ്പോൾ കേസ് പരിഗണിക്കുക, അപ്പോൾ അവൻ്റെ പ്രവർത്തനങ്ങൾ ഇപ്രകാരമായിരിക്കും. അവൻ മേശയിലേക്കുള്ള പ്രവേശനത്തിനായി കാത്തിരിക്കുകയാണ്. അത് സ്വീകരിച്ച്, അവൻ ഫോർക്കുകൾ എടുക്കാൻ ശ്രമിക്കുന്നു. വർക്ക് ഔട്ട് ആയില്ല. ഇത് പട്ടികയിലേക്കുള്ള പ്രവേശനം നൽകുന്നു (പരസ്പര ഒഴിവാക്കൽ). അവൻ തൻ്റെ "ടേൺസ്റ്റൈൽ" കടന്നുപോകുന്നു (AutoResetEvent) (ആദ്യം അവർ തുറന്നിരിക്കുന്നു). അത് വീണ്ടും ചക്രത്തിൽ വീഴുന്നു, കാരണം അവന് ചന്തികൾ ഇല്ല. അവൻ അവരെ എടുക്കാൻ ശ്രമിക്കുകയും തൻ്റെ "ടേൺസ്റ്റൈലിൽ" നിർത്തുകയും ചെയ്യുന്നു. വലത്തോട്ടോ ഇടത്തോട്ടോ ഭാഗ്യവാനായ ചില അയൽക്കാരൻ, ഭക്ഷണം കഴിച്ചുകഴിഞ്ഞാൽ, "അവൻ്റെ ടേൺസ്റ്റൈൽ തുറന്ന്" നമ്മുടെ തത്ത്വചിന്തകനെ തടഞ്ഞുനിർത്തും. നമ്മുടെ തത്ത്വചിന്തകൻ രണ്ടാമതും അതിലൂടെ കടന്നുപോകുന്നു (അത് അവൻ്റെ പിന്നിൽ അടയ്ക്കുന്നു). ഫോർക്കുകൾ എടുക്കാൻ മൂന്നാം തവണ ശ്രമിക്കുന്നു. വിജയിച്ചു. ഉച്ചഭക്ഷണം കഴിക്കാൻ അവൻ തൻ്റെ ടേൺസ്റ്റൈലിലൂടെ പോകുന്നു.

അത്തരം കോഡിൽ ക്രമരഹിതമായ പിശകുകൾ ഉണ്ടാകുമ്പോൾ (അവ എല്ലായ്പ്പോഴും നിലവിലുണ്ട്), ഉദാഹരണത്തിന്, ഒരു അയൽക്കാരനെ തെറ്റായി വ്യക്തമാക്കും അല്ലെങ്കിൽ അതേ ഒബ്ജക്റ്റ് സൃഷ്ടിക്കപ്പെടും AutoResetEvent എല്ലാവർക്കും (Enumerable.Repeat), അപ്പോൾ തത്ത്വചിന്തകർ ഡെവലപ്പർമാർക്കായി കാത്തിരിക്കും, കാരണം അത്തരം കോഡുകളിൽ പിശകുകൾ കണ്ടെത്തുന്നത് വളരെ ബുദ്ധിമുട്ടുള്ള കാര്യമാണ്. ഈ പരിഹാരത്തിൻ്റെ മറ്റൊരു പ്രശ്നം, ചില തത്ത്വചിന്തകർ പട്ടിണി കിടക്കില്ലെന്ന് ഇത് ഉറപ്പുനൽകുന്നില്ല എന്നതാണ്.

ഹൈബ്രിഡ് പരിഹാരങ്ങൾ

ഞങ്ങൾ ഉപയോക്തൃ മോഡിൽ തുടരുകയും ഒരു ലൂപ്പിൽ കറങ്ങുകയും കേർണലിലൂടെ ത്രെഡ് തടയുകയും ചെയ്യുമ്പോൾ, സമന്വയത്തിനുള്ള രണ്ട് സമീപനങ്ങൾ ഞങ്ങൾ പരിശോധിച്ചു. ആദ്യ രീതി ചെറിയ ബ്ലോക്കുകൾക്ക് നല്ലതാണ്, രണ്ടാമത്തേത് നീളമുള്ളവയ്ക്ക്. ഒരു ലൂപ്പിൽ ഒരു വേരിയബിൾ മാറുന്നതിനായി നിങ്ങൾ ആദ്യം ഹ്രസ്വമായി കാത്തിരിക്കേണ്ടതുണ്ട്, തുടർന്ന് കാത്തിരിപ്പ് ദീർഘമാകുമ്പോൾ ത്രെഡ് തടയുക. വിളിക്കപ്പെടുന്നവയിൽ ഈ സമീപനം നടപ്പിലാക്കുന്നു. ഹൈബ്രിഡ് ഡിസൈനുകൾ. ഇതിന് കേർണൽ മോഡിൻ്റെ അതേ നിർമ്മിതികളുണ്ട്, എന്നാൽ ഇപ്പോൾ ഒരു ഉപയോക്തൃ മോഡ് ലൂപ്പിനൊപ്പം: SemaphorSlim, ManualResetEventSlim മുതലായവ. ഇവിടെ ഏറ്റവും പ്രശസ്തമായ ഡിസൈൻ ആണ് Monitor, കാരണം C#-ൽ അറിയപ്പെടുന്ന ഒന്ന് ഉണ്ട് lock വാക്യഘടന. Monitor പരമാവധി മൂല്യം 1 (മ്യൂട്ടക്സ്) ഉള്ള അതേ സെമാഫോർ ആണ്, എന്നാൽ ഒരു ലൂപ്പിൽ കാത്തിരിക്കുന്നതിനുള്ള പിന്തുണ, ആവർത്തനം, കണ്ടീഷൻ വേരിയബിൾ പാറ്റേൺ (താഴെയുള്ളതിൽ കൂടുതൽ) മുതലായവ. അതിനുള്ള ഒരു പരിഹാരം നോക്കാം.

// Спрячем объект для Монитора от всех, чтобы без дедлоков.
private readonly object _lock = new object();
// Время ожидания потока.
private DateTime?[] _waitTimes = new DateTime?[philosophersAmount];

public void Run(int i, CancellationToken token)
{
    while (true)
    {
        TakeForks(i);
        eatenFood[i] = (eatenFood[i] + 1) % (int.MaxValue - 1);
        PutForks(i);
        Think(i);
        if (token.IsCancellationRequested) break;
    }
}

// Наше сложное условие для Condition Variable паттерна.
bool CanIEat(int i)
{
    // Если есть вилки:
    if (forks[Left(i)] != 0 && forks[Right(i)] != 0)
        return false;
    var now = DateTime.Now;
    // Может, если соседи не более голодные, чем текущий.
    foreach(var p in new int[] {LeftPhilosopher(i), RightPhilosopher(i)})
        if (_waitTimes[p] != null && now - _waitTimes[p] > now - _waitTimes[i])
            return false;
    return true;
}

void TakeForks(int i)
{
    // Зайти в Монитор. То же самое: lock(_lock) {..}.
    // Вызываем вне try, чтобы возможное исключение выбрасывалось выше.
    bool lockTaken = false;
    Monitor.Enter(_lock, ref lockTaken);
    try
    {
        _waitTimes[i] = DateTime.Now;
        // Condition Variable паттерн. Освобождаем лок, если не выполненно 
        // сложное условие. И ждем пока кто-нибудь сделает Pulse / PulseAll.
        while (!CanIEat(i))
            Monitor.Wait(_lock); 
        forks[Left(i)] = i + 1;
        forks[Right(i)] = i + 1;
        _waitTimes[i] = null;
    }
    finally
    {
        if (lockTaken) Monitor.Exit(_lock);
    }
}

void PutForks(int i)
{
    // То же самое: lock (_lock) {..}.
    bool lockTaken = false;
    Monitor.Enter(_lock, ref lockTaken);
    try
    {
        forks[Left(i)] = 0;
        forks[Right(i)] = 0;
        // Освободить все потоки в очереди ПОСЛЕ вызова Monitor.Exit.
        Monitor.PulseAll(_lock); 
    }
    finally
    {
        if (lockTaken) Monitor.Exit(_lock);
    }
}

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

ഇതുവഴി ചില തത്ത്വചിന്തകരുടെ പട്ടിണിയും പ്രതിസന്ധികളും ഒഴിവാക്കുന്നു. ഒരു ചെറിയ സമയം കാത്തിരിക്കാനും ദീർഘനേരം ത്രെഡ് തടയാനും ഞങ്ങൾ ഒരു ലൂപ്പ് ഉപയോഗിക്കുന്നു. എല്ലാവരേയും ഒരേസമയം അൺബ്ലോക്ക് ചെയ്യുന്നത് അയൽക്കാരനെ മാത്രം അൺലോക്ക് ചെയ്തതിനേക്കാൾ വേഗത കുറവാണ്, പരിഹാരത്തിലെന്നപോലെ AutoResetEvent, എന്നാൽ വ്യത്യാസം വലുതായിരിക്കരുത്, കാരണം ത്രെഡുകൾ ആദ്യം ഉപയോക്തൃ മോഡിൽ നിലനിൽക്കണം.

У lock വാക്യഘടനയിൽ ചില അസുഖകരമായ ആശ്ചര്യങ്ങളുണ്ട്. ഉപയോഗിക്കാൻ ശുപാർശ ചെയ്യുന്നു Monitor നേരിട്ട് [റിക്ടർ] [എറിക് ലിപ്പർട്ട്]. അതിലൊന്നാണ് അത് lock എപ്പോഴും പുറത്തുവരുന്നു Monitor, ഒരു അപവാദം ഉണ്ടായാലും, മറ്റൊരു ത്രെഡിന് പങ്കിട്ട മെമ്മറിയുടെ അവസ്ഥ മാറ്റാൻ കഴിയും. അത്തരം സന്ദർഭങ്ങളിൽ, ഒരു സ്തംഭനാവസ്ഥയിലേക്ക് പോകുകയോ എങ്ങനെയെങ്കിലും സുരക്ഷിതമായി പ്രോഗ്രാം അവസാനിപ്പിക്കുകയോ ചെയ്യുന്നതാണ് നല്ലത്. മോണിറ്റർ ക്ലോക്ക് ബ്ലോക്കുകൾ ഉപയോഗിക്കുന്നു എന്നതാണ് മറ്റൊരു ആശ്ചര്യം (SyncBlock), എല്ലാ വസ്തുക്കളിലും ഉണ്ട്. അതിനാൽ, അനുചിതമായ ഒരു ഒബ്‌ജക്റ്റ് തിരഞ്ഞെടുത്തിട്ടുണ്ടെങ്കിൽ, നിങ്ങൾക്ക് എളുപ്പത്തിൽ ഒരു ഡെഡ്‌ലോക്ക് ലഭിക്കും (ഉദാഹരണത്തിന്, നിങ്ങൾ ഒരു ഇൻ്റേൺഡ് സ്ട്രിംഗിൽ ലോക്ക് ചെയ്യുകയാണെങ്കിൽ). ഇതിനായി നമ്മൾ എപ്പോഴും ഒരു മറഞ്ഞിരിക്കുന്ന വസ്തുവാണ് ഉപയോഗിക്കുന്നത്.

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

നിരവധി തത്ത്വചിന്തകർ അല്ലെങ്കിൽ async / await

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

SemaphoreSlim ഇതിനായി ഉണ്ട് WaitAsync() രീതി. ഈ പാറ്റേൺ ഉപയോഗിച്ചുള്ള ഒരു നടപ്പാക്കൽ ഇതാ.

// Запуск такой же, как раньше. Где-нибудь в программе:
Task.Run(() => Run(i, cancelTokenSource.Token));

// Запуск философа.
// Ключевое слово async -- компилятор транслирует этот метот в асинхронный.
public async Task Run(int i, CancellationToken token)
{
    while (true)
    {
        // await -- будем ожидать какого-то события.
        await TakeForks(i);
        // После await, продолжение возможно в другом потоке.
        eatenFood[i] = (eatenFood[i] + 1) % (int.MaxValue - 1);
        // Может быть несколько событий для ожидания.
        await PutForks(i);

        Think(i);

        if (token.IsCancellationRequested) break;
    }
}

async Task TakeForks(int i)
{
    bool hasForks = false;
    while (!hasForks)
    {
        // Взаимоисключающий доступ к столу:
        await _tableSemaphore.WaitAsync();
        if (forks[Left(i)] == 0 && forks[Right(i)] == 0)
        {
            forks[Left(i)] = i+1;
            forks[Right(i)] = i+1;
            hasForks = true;
        }
        _tableSemaphore.Release();
        // Будем ожидать, чтобы сосед положил вилки:
        if (!hasForks)
            await _philosopherSemaphores[i].WaitAsync();
    }
}

// Ждем доступа к столу и кладем вилки.
async Task PutForks(int i)
{
    await _tableSemaphore.WaitAsync();
    forks[Left(i)] = 0;
    // "Пробудить" соседей, если они "спали".
    _philosopherSemaphores[LeftPhilosopher(i)].Release();
    forks[Right(i)] = 0;
    _philosopherSemaphores[RightPhilosopher(i)].Release();
    _tableSemaphore.Release();
}

കൂടെ രീതി async / await ഒരു തന്ത്രശാലിയായ ഫിനിറ്റ് സ്റ്റേറ്റ് മെഷീനായി വിവർത്തനം ചെയ്യപ്പെടുന്നു, അത് ഉടനടി അതിൻ്റെ ആന്തരികം തിരികെ നൽകുന്നു Task. അതിലൂടെ, രീതി പൂർത്തിയാകുന്നതുവരെ നിങ്ങൾക്ക് കാത്തിരിക്കാം, അത് റദ്ദാക്കാം, കൂടാതെ ടാസ്ക് ഉപയോഗിച്ച് നിങ്ങൾക്ക് ചെയ്യാൻ കഴിയുന്ന മറ്റെല്ലാം. രീതിക്കുള്ളിൽ, ഒരു സ്റ്റേറ്റ് മെഷീൻ നിർവ്വഹണം നിയന്ത്രിക്കുന്നു. കാലതാമസമില്ലെങ്കിൽ, നിർവ്വഹണം സമന്വയമാണ്, ഉണ്ടെങ്കിൽ, ത്രെഡ് റിലീസ് ചെയ്യപ്പെടും എന്നതാണ് പ്രധാന കാര്യം. ഇത് നന്നായി മനസ്സിലാക്കാൻ, ഈ സംസ്ഥാന യന്ത്രം നോക്കുന്നതാണ് നല്ലത്. ഇവയിൽ നിന്ന് നിങ്ങൾക്ക് ചങ്ങലകൾ ഉണ്ടാക്കാം async / await രീതികൾ.

നമുക്ക് അത് പരീക്ഷിക്കാം. 100 ലോജിക്കൽ കോറുകളുള്ള ഒരു മെഷീനിൽ 4 ​​തത്ത്വചിന്തകരുടെ ജോലി, 8 സെക്കൻഡ്. മോണിറ്ററുമായുള്ള മുൻ സൊല്യൂഷൻ ആദ്യത്തെ 4 ത്രെഡുകൾ മാത്രമേ എക്‌സിക്യൂട്ട് ചെയ്‌തുള്ളൂ, ബാക്കിയുള്ളവ എക്‌സിക്യൂട്ട് ചെയ്‌തില്ല. ഈ 4 ത്രെഡുകളിൽ ഓരോന്നും ഏകദേശം 2 മി. കൂടാതെ, അസിൻക് / വെയിറ്റ് സൊല്യൂഷൻ 100 എല്ലാം ചെയ്തു, ശരാശരി 6.8 സെക്കൻഡ് ഓരോ കാത്തിരിപ്പും. തീർച്ചയായും, യഥാർത്ഥ സിസ്റ്റങ്ങളിൽ, 6 സെക്കൻഡ് നിഷ്‌ക്രിയമായിരിക്കുന്നത് അസ്വീകാര്യമാണ്, മാത്രമല്ല ഇത്രയും അഭ്യർത്ഥനകൾ ഈ രീതിയിൽ പ്രോസസ്സ് ചെയ്യാതിരിക്കുന്നതാണ് നല്ലത്. മോണിറ്ററുമായുള്ള പരിഹാരം സ്കെയിലബിൾ അല്ലെന്ന് തെളിഞ്ഞു.

തീരുമാനം

ഈ ചെറിയ ഉദാഹരണങ്ങളിൽ നിന്ന് നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, .NET നിരവധി സിൻക്രൊണൈസേഷൻ നിർമ്മാണങ്ങളെ പിന്തുണയ്ക്കുന്നു. എന്നിരുന്നാലും, അവ എങ്ങനെ ഉപയോഗിക്കണമെന്ന് എല്ലായ്പ്പോഴും വ്യക്തമല്ല. ഈ ലേഖനം സഹായകരമാണെന്ന് ഞാൻ പ്രതീക്ഷിക്കുന്നു. ഞങ്ങൾ ഇത് ഇപ്പോൾ പൊതിയുകയാണ്, എന്നാൽ ഇനിയും രസകരമായ ഒരുപാട് കാര്യങ്ങൾ ബാക്കിയുണ്ട്, ഉദാഹരണത്തിന്, ത്രെഡ്-സേഫ് കളക്ഷനുകൾ, TPL ഡാറ്റഫ്ലോ, റിയാക്ടീവ് പ്രോഗ്രാമിംഗ്, സോഫ്റ്റ്‌വെയർ ഇടപാട് മോഡൽ മുതലായവ.

ഉറവിടങ്ങൾ

• ഫ്ലോ ദൃശ്യവൽക്കരണം: കൺകറൻസി വിഷ്വലൈസർ
• MSDN: ത്രെഡിംഗ്, അസിൻക്രണസ് പ്രോഗ്രാമിംഗ് പാറ്റേണുകൾ ഞാൻ mn. ഡോ.
• [റിക്ടർ] — CLR വഴി C#, ജെഫ്രി റിക്ടർ
• [എറിക് ലിപ്പർട്ട്] - ലോക്കിനെ കുറിച്ച്
• ഉറവിട കോഡ്
• ചിത്രം - "വാളുകൾക്കിടയിൽ നൃത്തം", ജി സെമിറാഡ്സ്കി

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