በደንብ የተመገቡ ፈላስፎች ወይም ተወዳዳሪ .NET ፕሮግራሚንግ

የፈላስፋዎች የመመገቢያ ችግርን እንደ ምሳሌ በመጠቀም በኔት ላይ የተጣጣመ እና ትይዩ ፕሮግራሚንግ እንዴት እንደሚሰራ እንይ። እቅዱ ይህ ነው, ክሮች / ሂደቶችን ከማመሳሰል, ወደ ተዋናይ ሞዴል (በሚከተሉት ክፍሎች). ጽሑፉ ለመጀመሪያው ትውውቅ ወይም እውቀትዎን ለማደስ ጠቃሚ ሊሆን ይችላል።

ለምንድነው በጭራሽ? ትራንዚስተሮች በትንሹ መጠናቸው ላይ ይደርሳሉ, የሙር ህግ በብርሃን ፍጥነት ገደብ ላይ የተመሰረተ ነው, ስለዚህም በቁጥር መጨመር ይታያል, ብዙ ትራንዚስተሮች ሊደረጉ ይችላሉ. በተመሳሳይ ጊዜ የውሂብ መጠን እያደገ ነው, እና ተጠቃሚዎች ከስርአቶች አፋጣኝ ምላሽ ይጠብቃሉ. በእንደዚህ ዓይነት ሁኔታ, "የተለመደ" ፕሮግራም, አንድ የማስፈጸሚያ ክር ሲኖረን, ከአሁን በኋላ ውጤታማ አይደለም. በአንድ ጊዜ ወይም በአንድ ጊዜ የአፈፃፀም ችግርን በሆነ መንገድ መፍታት ያስፈልግዎታል። ከዚህም በላይ ይህ ችግር በተለያዩ ደረጃዎች ውስጥ ይገኛል: በክሮች ደረጃ, በሂደት ደረጃ, በኔትወርክ ውስጥ ባሉ ማሽኖች (የተከፋፈሉ ስርዓቶች). .NET እንደዚህ አይነት ችግሮችን በፍጥነት እና በብቃት ለመፍታት ከፍተኛ ጥራት ያላቸው፣ በጊዜ የተሞከሩ ቴክኖሎጂዎች አሉት።

ዓላማ

Edsger Dijkstra ይህንን ችግር ለተማሪዎቹ እንደ 1965 አቅርቧል። የተቋቋመው ቀመር እንደሚከተለው ነው። የተወሰነ (ብዙውን ጊዜ አምስት) የፈላስፎች ቁጥር እና ተመሳሳይ የሹካዎች ብዛት አለ። ክብ ጠረጴዛ ላይ ተቀምጠዋል, በመካከላቸው ሹካዎች. ፈላስፋዎች ማለቂያ የሌለውን ምግብ ከሳህናቸው መብላት፣ ማሰብ ወይም መጠበቅ ይችላሉ። ፈላስፋን ለመብላት, ሁለት ሹካዎችን መውሰድ ያስፈልግዎታል (የመጨረሻው ሹካውን ከመጀመሪያው ጋር ይጋራል). ሹካ ማንሳት እና ማስቀመጥ ሁለት የተለያዩ ተግባራት ናቸው። ሁሉም ፈላስፎች ዝም አሉ። ስራው ሁሉም ከ 54 አመታት በኋላ እንኳን የሚያስቡ እና የሚሞሉበት እንዲህ አይነት ስልተ-ቀመር ማግኘት ነው.

በመጀመሪያ, ይህንን ችግር በጋራ ቦታ በመጠቀም ለመፍታት እንሞክር. ሹካዎቹ በጋራ ጠረጴዛ ላይ ይተኛሉ እና ፈላስፋዎቹ በቀላሉ ሲገኙ ወስደው ይመለሳሉ. እዚህ በማመሳሰል ላይ ችግሮች አሉ፣ መቼ በትክክል surebets መውሰድ? ሹካ ከሌለስ? ወዘተ ግን መጀመሪያ ፈላስፋዎቹን እንጀምር።

ክሮች ለመጀመር, በክር ገንዳ እንጠቀማለን 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, ነገር ግን ከሁሉም አይነት ምቾት ጋር-ከሌሎች ተግባራት እገዳ በኋላ አንድን ተግባር የማሄድ ችሎታ, ከተግባሮች መመለስ, ምቹ በሆነ ሁኔታ ማቋረጥ እና ሌሎችንም. ወዘተ የሚሠሩትን ግንባታዎች (በተግባር ላይ የተመሰረተ Asynchronous Pattern, syntactic sugar for IO ስራዎችን ለመጠበቅ) ለመደገፍ ያስፈልጋሉ. ስለዚህ ጉዳይ በኋላ እንነጋገራለን.

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።

በሥዕሉ ላይ, የማገጃ ክሮች (deadlock). አረንጓዴ - ማስፈጸሚያ, ቀይ - ማመሳሰል, ግራጫ - ክር ተኝቷል. ራምቡሶች የተግባር መጀመሪያ ጊዜን ያመለክታሉ።

የፈላስፎች ረሃብ

ምንም እንኳን በተለይ ብዙ ምግብን ማሰብ አስፈላጊ ባይሆንም ረሃብ ግን ማንም ሰው ፍልስፍናን እንዲተው ያደርገዋል. በችግራችን ውስጥ ክሮች የተራቡበትን ሁኔታ ለመምሰል እንሞክር. ረሃብ ማለት ክር ሲሮጥ ነው, ነገር ግን ጉልህ የሆነ ስራ ከሌለ, በሌላ አነጋገር, ይህ ተመሳሳይ የሞት መቆለፊያ ነው, አሁን ክሩ አይተኛም, ነገር ግን የሚበላ ነገርን በንቃት እየፈለገ ነው, ነገር ግን ምንም ምግብ የለም. ተደጋጋሚ እገዳን ለማስቀረት, ሌላ መውሰድ ካልቻልን ሹካውን እናስቀምጠዋለን.

// То же что и в 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 ፃፍ መጥፎ ነው) ለአንድ እሴት ውስብስብ ለውጦችን መጠቀም ይቻላል (የተጠላለፈ ማንኛውም ነገር ንድፍ) .

የከርነል ሁነታ መፍትሄዎች

በ loop ውስጥ ሀብትን ላለማባከን፣ ክርን እንዴት እንደምናገድብ እንይ። በሌላ አነጋገር፣ ምሳሌአችንን በመቀጠል፣ አስተናጋጁ ፈላስፋውን እንዴት እንደሚያንቀላፋ እና አስፈላጊ ሲሆን ብቻ እንደሚያስነሳው እንመልከት። በመጀመሪያ ፣ ይህንን በስርዓተ ክወናው የከርነል ሁኔታ እንዴት እንደምናደርግ እንመልከት ። እዚያ ያሉት ሁሉም መዋቅሮች በተጠቃሚ ቦታ ውስጥ ካሉት ይልቅ ቀርፋፋ ናቸው። ብዙ ጊዜ ቀርፋፋ፣ ለምሳሌ AutoResetEvent ምናልባት 53 ጊዜ ቀርፋፋ SpinLock [ሪችተር]። ነገር ግን በእነሱ እርዳታ በስርዓቱ ውስጥ ያሉትን ሂደቶች ማመሳሰል ይችላሉ, የሚተዳደርም ሆነ አይደለም.

እዚህ ያለው መሠረታዊ ግንባታ ከግማሽ ምዕተ ዓመት በፊት በዲጅክስታራ የቀረበው ሴማፎር ነው። ሴማፎር በቀላል አነጋገር በስርዓቱ የሚተዳደር አዎንታዊ ኢንቲጀር እና በላዩ ላይ ሁለት ክዋኔዎች መጨመር እና መቀነስ ናቸው። መቀነስ ካልተሳካ, ዜሮ, ከዚያም የጥሪው ክር ታግዷል. ቁጥሩ በሌላ ገባሪ ክር/ሂደት ሲጨመር ክሩቹ ተዘለዋል እና ሴማፎሩ እንደገና በተላለፈው ቁጥር ይቀንሳል። ባቡሮችን በጠርሙስ አንገት ከሴማፎር ጋር መገመት ይቻላል። .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), ከዚያ ፈላስፋዎቹ ገንቢዎችን ይጠብቃሉ, ምክንያቱም በእንደዚህ ዓይነት ኮድ ውስጥ ስህተቶችን መፈለግ በጣም ከባድ ስራ ነው። ሌላው የዚህ መፍትሔ ችግር አንዳንድ ፈላስፋዎች እንዳይራቡ ዋስትና አለመስጠቱ ነው።

ድብልቅ መፍትሄዎች

በተጠቃሚ ሁነታ እና ሉፕ ውስጥ ስንቆይ እና በከርነል ውስጥ ክር ስንዘጋ ሁለት አቀራረቦችን ተመልክተናል። የመጀመሪያው ዘዴ ለአጭር መቆለፊያዎች ጥሩ ነው, ሁለተኛው ደግሞ ለረጅም ጊዜ ነው. ብዙውን ጊዜ በመጀመሪያ አንድ ተለዋዋጭ በ loop ውስጥ እስኪቀየር ድረስ ለአጭር ጊዜ መጠበቅ እና ጥበቃው ረጅም በሚሆንበት ጊዜ ክርውን ማገድ ያስፈልጋል። ይህ አቀራረብ በሚባሉት ውስጥ ተተግብሯል. ድብልቅ መዋቅሮች. ከከርነል ሁነታ ጋር ተመሳሳይ ግንባታዎች እዚህ አሉ፣ አሁን ግን በተጠቃሚ ሁነታ ዑደት፦ SemaphorSlim, ManualResetEventSlim ወዘተ እዚህ በጣም ታዋቂው ንድፍ ነው Monitor, ምክንያቱም በ C # ውስጥ በጣም የታወቀ ነገር አለ lock አገባብ። Monitor ይህ ከፍተኛው 1 (mutex) ያለው ተመሳሳይ ሴማፎር ነው፣ ነገር ግን በ loop ውስጥ ለመጠበቅ ድጋፍ ፣ ተደጋጋሚነት ፣ የሁኔታ ተለዋዋጭ ንድፍ (ከዚህ በታች የበለጠ) ፣ ወዘተ. ከእሱ ጋር አንድ መፍትሄ እንይ።

// Спрячем объект для Монитора от всех, чтобы без дедлоков.
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);
    }
}

እዚህ እንደገና ወደ ሹካዎች ለመድረስ ሙሉውን ጠረጴዛ እየዘጋን ነው, አሁን ግን ሁሉንም ክሮች በአንድ ጊዜ እንከፍታለን, እና አንድ ሰው በልቶ ሲጨርስ ጎረቤቶች አይደለም. እነዚያ። በመጀመሪያ አንድ ሰው ይበላል እና ጎረቤቶቹን ያግዳል, እና ይህ ሰው ሲጨርስ, ነገር ግን እንደገና መብላት ሲፈልግ, ወደ ማገድ ሄዶ ጎረቤቶቹን ያስነሳል, ምክንያቱም. የእሱ ጥበቃ ጊዜ ያነሰ ነው.

በዚህ መንገድ ነው ከሞት መዘጋት እና የአንዳንድ ፈላስፋዎችን ረሃብ የምናስወግደው። ለአጭር ጊዜ ለመጠበቅ አንድ loop እንጠቀማለን እና ክርውን ለረጅም ጊዜ እንዘጋዋለን. ሁሉንም ሰው በአንድ ጊዜ ማንሳት ጎረቤት ብቻ ከመታገድ ይልቅ ቀርፋፋ ነው፣ እንደ መፍትሄው AutoResetEvent, ግን ልዩነቱ ትልቅ መሆን የለበትም, ምክንያቱም ክሮች መጀመሪያ በተጠቃሚ ሁኔታ ውስጥ መቆየት አለባቸው።

У lock አገባብ አስቀያሚ አስገራሚ ነገሮች አሉት። ለመጠቀም ይመከራል Monitor በቀጥታ [Richter] [Eric Lippert]. ከመካከላቸው አንዱ ያ ነው። 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 ሰከንድ ባለው ማሽን ላይ። ከMonitor ጋር የነበረው የቀደመው መፍትሄ የመጀመሪያዎቹን 4 ክሮች ብቻ ነው የሄደው እና የተቀረው ምንም አልሄደም። እያንዳንዳቸው እነዚህ 4 ክሮች ለ 2 ሚሰ ያህል ስራ ፈትተዋል። እና የአስንክ/የመጠባበቅ መፍትሄው 100ቱን ሮጦ ነበር፣በእያንዳንዳቸው በአማካይ 6.8 ሰከንድ እየጠበቀ። እርግጥ ነው, በእውነተኛ ስርዓቶች ውስጥ, ለ 6 ሰከንድ ስራ ፈትነት ተቀባይነት የለውም እና እንደዚህ አይነት ብዙ ጥያቄዎችን ላለመፈጸም የተሻለ ነው. ከMonitor ጋር ያለው መፍትሄ ጨርሶ ሊሰፋ የማይችል ሆኖ ተገኝቷል።

መደምደሚያ

ከእነዚህ ትናንሽ ምሳሌዎች ማየት እንደምትችለው፣ NET ብዙ የማመሳሰል ግንባታዎችን ይደግፋል። ሆኖም ግን, እንዴት እንደሚጠቀሙባቸው ሁልጊዜ ግልጽ አይደለም. ይህ ጽሑፍ ጠቃሚ ነበር ብዬ ተስፋ አደርጋለሁ። ለአሁን፣ ይህ መጨረሻው ነው፣ ነገር ግን አሁንም ብዙ አስደሳች ነገሮች ቀርተዋል፣ ለምሳሌ፣ ክር-አስተማማኝ ስብስቦች፣ TPL Dataflow፣ Reactive programming፣ የሶፍትዌር ግብይት ሞዴል፣ ወዘተ።

ምንጮች

• የፍሰት እይታ Concurrency Visualizer
• MSDN ተከታታይ, ያልተመሳሰሉ የፕሮግራም ንድፎች እና ሌሎችም ሌላ።
• [ሪችተር] - CLR በ C # በኩል ፣ ጄፍሪ ሪችተር
• (ኤሪክ ሊፐርት) - ስለ መቆለፊያ
• ምንጭ ኮድ
• ስዕል - "በሰይፍ መካከል ዳንስ", ጂ ሴሚራድስኪ

ምንጭ: hab.com