Well-Fed Philosophers ឬ Competitive .NET Programming

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

ហេតុអ្វីក៏ចេះធ្វើបែបនេះ? ត្រង់ស៊ីស្ទ័រកំពុងឈានដល់ទំហំអប្បបរមារបស់ពួកគេ ច្បាប់របស់ Moore កំពុងឈានដល់កម្រិតនៃល្បឿនពន្លឺ ហើយដូច្នេះការរីកចម្រើនត្រូវបានគេសង្កេតឃើញជាចំនួន ត្រង់ស៊ីស្ទ័រកាន់តែច្រើនអាចត្រូវបានធ្វើឡើង។ ទន្ទឹមនឹងនេះបរិមាណទិន្នន័យកំពុងកើនឡើង ហើយអ្នកប្រើប្រាស់រំពឹងថានឹងមានការឆ្លើយតបភ្លាមៗពីប្រព័ន្ធ។ ក្នុង​ស្ថានភាព​បែប​នេះ ការ​សរសេរ​កម្មវិធី "ធម្មតា" នៅ​ពេល​ដែល​យើង​មាន​ខ្សែ​ស្រឡាយ​ប្រតិបត្តិ​មួយ មិន​មាន​ប្រសិទ្ធភាព​ទៀត​ទេ។ យើងត្រូវដោះស្រាយបញ្ហានៃការប្រតិបត្តិក្នុងពេលដំណាលគ្នា ឬស្របគ្នា។ លើសពីនេះទៅទៀតបញ្ហានេះមាននៅកម្រិតផ្សេងៗគ្នា: នៅកម្រិតខ្សែស្រឡាយនៅកម្រិតដំណើរការនៅកម្រិតម៉ាស៊ីននៅលើបណ្តាញ (ប្រព័ន្ធចែកចាយ) ។ .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 ។

នៅក្នុងរូបភាពការទប់ស្កាត់ខ្សែស្រឡាយ (ជាប់គាំង) ។ ពណ៌បៃតងបង្ហាញពីការប្រតិបត្តិ ពណ៌ក្រហមបង្ហាញពីការធ្វើសមកាលកម្ម ហើយពណ៌ប្រផេះបង្ហាញថាខ្សែស្រឡាយកំពុងដេក។ Diamonds បង្ហាញពីពេលវេលាចាប់ផ្តើមនៃ Tasks ។

ការស្រេកឃ្លាននៃទស្សនវិទូ

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

// То же что и в 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 និងល)។ ដូច្នេះ អ្នកដោះស្រាយកំហុសគឺត្រូវការជាចាំបាច់នៅក្នុងខ្សែស្រឡាយដោយខ្លួនឯង និងជាមួយនឹងការបញ្ចប់ប្រកបដោយភាពទន់ភ្លន់។

អ្នករត់តុ

យល់ព្រម តើ​យើង​ដោះស្រាយ​បញ្ហា​ជាប់គាំង ការអត់ឃ្លាន និង​ការស្លាប់​នេះ​ដោយ​របៀបណា? យើង​នឹង​អនុញ្ញាត​ឱ្យ​ទស្សនវិទូ​តែ​ម្នាក់​គត់​ទៅ​កាន់​សម ហើយ​យើង​នឹង​បន្ថែម​ការ​មិន​រាប់​បញ្ចូល​គ្នា​ទៅ​វិញ​ទៅ​មក​នៃ​ខ្សែស្រឡាយ​សម្រាប់​កន្លែង​នេះ។ តើត្រូវធ្វើដូចម្តេច? ឧបមាថា នៅក្បែរទស្សនវិទូ មានអ្នករត់តុម្នាក់ ដែលអនុញ្ញាតិឱ្យទស្សនវិទូម្នាក់យកសម។ តើយើងគួរបង្កើតអ្នករត់តុនេះដោយរបៀបណា ហើយតើទស្សនវិទូនឹងសួរគាត់ដោយរបៀបណា គឺជាសំណួរគួរឱ្យចាប់អារម្មណ៍។

មធ្យោបាយដ៏សាមញ្ញបំផុតគឺសម្រាប់ទស្សនវិទូគ្រាន់តែសួរអ្នករត់តុឱ្យជាប់ជានិច្ច។ ទាំងនោះ។ ឥឡូវនេះទស្សនវិទូនឹងមិនរង់ចាំសម្រាប់សមនៅក្បែរនោះទេតែរង់ចាំឬសួរអ្នករត់តុ។ ដំបូងឡើយ យើងប្រើតែ User Space សម្រាប់វា ហើយនៅក្នុងនោះ យើងមិនប្រើការរំខានដើម្បីហៅដំណើរការណាមួយពីខឺណែលទេ (បន្ថែមលើពួកវាខាងក្រោម)។

ដំណោះស្រាយទំហំអ្នកប្រើប្រាស់

នៅទីនេះយើងនឹងធ្វើដូចគ្នាដែលយើងបានធ្វើពីមុនជាមួយនឹងសមមួយ និងទស្សនវិទូពីរនាក់ យើងនឹងបង្វិលរង្វិលជុំមួយ ហើយរង់ចាំ។ ប៉ុន្តែឥឡូវនេះ វានឹងក្លាយជាទស្សនវិទូទាំងអស់ ហើយដូចដែលវាធ្លាប់មាន មានតែសមមួយប៉ុណ្ណោះ ពោលគឺឧ។ យើង​អាច​និយាយ​បាន​ថា​មាន​តែ​ទស្សនវិទូ​ម្នាក់​គត់​ដែល​បាន​យក​«​កំបោរ​មាស​»​ពី​អ្នក​រត់​តុ​នឹង​ស៊ី។ ដើម្បីធ្វើដូចនេះយើងប្រើ 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 [រិចទ័រ] ។ ប៉ុន្តែដោយមានជំនួយរបស់ពួកគេ អ្នកអាចធ្វើសមកាលកម្មដំណើរការនៅទូទាំងប្រព័ន្ធទាំងមូល គ្រប់គ្រងឬអត់។

ការរចនាជាមូលដ្ឋាននៅទីនេះគឺជា semaphore ដែលស្នើឡើងដោយ Dijkstra ជាងកន្លះសតវត្សមុន។ Semaphore គឺនិយាយដោយសាមញ្ញថា ចំនួនគត់វិជ្ជមានដែលគ្រប់គ្រងដោយប្រព័ន្ធ និងប្រតិបត្តិការពីរនៅលើវា - បង្កើន និងបន្ថយ។ ប្រសិនបើមិនអាចកាត់បន្ថយសូន្យបានទេនោះ ខ្សែទូរស័ព្ទត្រូវបានរារាំង។ នៅពេលដែលចំនួនត្រូវបានកើនឡើងដោយខ្សែស្រឡាយ/ដំណើរការសកម្មមួយចំនួនផ្សេងទៀត នោះខ្សែស្រឡាយត្រូវបានឆ្លងកាត់ ហើយ semaphore ត្រូវបានកាត់បន្ថយម្តងទៀតដោយចំនួនដែលបានឆ្លងកាត់។ អ្នក​អាច​ស្រមៃ​មើល​រថភ្លើង​នៅ​ក្នុង​ការ​កកស្ទះ​ជាមួយ​នឹង​សញ្ញា​សម្គាល់។ .NET ផ្តល់នូវសំណង់ជាច្រើនដែលមានមុខងារស្រដៀងគ្នា៖ AutoResetEvent, ManualResetEvent, Mutex និងខ្លួនខ្ញុំផ្ទាល់ Semaphore. យើងនឹងប្រើ AutoResetEventនេះ​គឺ​ជា​ការ​សាមញ្ញ​បំផុត​នៃ​ការ​សាង​សង់​ទាំង​នេះ៖ មាន​តែ​តម្លៃ​ពីរ ០ និង ១ (មិន​ពិត ពិត)។ វិធីសាស្រ្តរបស់នាង WaitOne() រារាំង​ខ្សែ​ការ​ហៅ​ទូរសព្ទ ប្រសិនបើ​តម្លៃ​គឺ 0 ហើយ​ប្រសិនបើ 1 នោះ​ទម្លាក់​វា​ទៅ 0 ហើយ​រំលង​វា។ វិធីសាស្រ្តមួយ។ Set() កើនឡើងដល់ 1 និងអនុញ្ញាតឱ្យមនុស្សម្នាក់ឆ្លងកាត់ ដែលម្តងទៀតបន្ថយមកត្រឹម 0។ ធ្វើសកម្មភាពដូចជា turnstile នៅក្នុងរថភ្លើងក្រោមដី។

ចូរធ្វើឱ្យស្មុគស្មាញដល់ដំណោះស្រាយ ហើយប្រើការទប់ស្កាត់សម្រាប់ទស្សនវិទូម្នាក់ៗ ហើយមិនមែនសម្រាប់ទាំងអស់គ្នាក្នុងពេលតែមួយនោះទេ។ ទាំងនោះ។ ឥឡូវ​នេះ ទស្សនវិទូ​ជាច្រើន​អាច​ញ៉ាំ​ក្នុងពេលតែមួយ ហើយ​មិនមែន​តែមួយ​មុខ​ទេ។ ប៉ុន្តែ យើង​បិទ​ការ​ចូល​ទៅ​តុ​ម្ដង​ទៀត ដើម្បី​យក​សម​បាន​ត្រឹម​ត្រូវ ជៀសវាង​លក្ខខណ្ឌ​ការ​ប្រណាំង។

// Для блокирования отдельного философа.
// Инициализируется: 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 នេះគឺជា semaphore ដូចគ្នាជាមួយនឹងតម្លៃអតិបរមានៃ 1 (mutex) ប៉ុន្តែជាមួយនឹងការគាំទ្រសម្រាប់ការរង់ចាំនៅក្នុងរង្វិលជុំ ការបង្កើតឡើងវិញ លក្ខខណ្ឌអថេរលំនាំ (ច្រើនទៀតនៅលើនោះខាងក្រោម) ។ល។ សូមក្រឡេកមើលដំណោះស្រាយជាមួយវា។

// Спрячем объект для Монитора от всех, чтобы без дедлоков.
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 ដោយផ្ទាល់ [Richter] [Eric Lippert] ។ មួយក្នុងចំណោមពួកគេគឺនោះ។ lock តែងតែចេញមក Monitorទោះបីជាមានករណីលើកលែងមួយ ហើយបន្ទាប់មក ខ្សែផ្សេងទៀតអាចផ្លាស់ប្តូរស្ថានភាពនៃអង្គចងចាំដែលបានចែករំលែក។ ក្នុងករណីបែបនេះ វាជាការប្រសើរក្នុងការចូលទៅក្នុងភាពជាប់គាំង ឬបញ្ចប់កម្មវិធីដោយសុវត្ថិភាព។ ការភ្ញាក់ផ្អើលមួយទៀតគឺថាម៉ូនីទ័រប្រើប្លុកនាឡិកា (SyncBlock) ដែលមាននៅក្នុងវត្ថុទាំងអស់។ ដូច្នេះ ប្រសិនបើវត្ថុមិនសមរម្យមួយត្រូវបានជ្រើសរើស អ្នកអាចទទួលបានការជាប់គាំងបានយ៉ាងងាយស្រួល (ឧទាហរណ៍ ប្រសិនបើអ្នកចាក់សោនៅលើខ្សែអក្សរដែលដំណើរការ)។ យើងតែងតែប្រើវត្ថុលាក់សម្រាប់រឿងនេះ។

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

ទស្សនវិទូជាច្រើនឬ async / await

មិនអីទេ ឥឡូវនេះយើងអាចទប់ស្កាត់ខ្សែស្រឡាយបានយ៉ាងមានប្រសិទ្ធភាព។ ប៉ុន្តែ ចុះ​បើ​យើង​មាន​ទស្សនវិទូ​ច្រើន? 100? 10000? ឧទាហរណ៍ យើងបានទទួលសំណើ 100000 ទៅកាន់ម៉ាស៊ីនមេគេហទំព័រ។ ការបង្កើតខ្សែស្រឡាយសម្រាប់សំណើនីមួយៗនឹងមានតម្លៃថ្លៃព្រោះ ដូច្នេះ ខ្សែស្រឡាយជាច្រើននឹងមិនត្រូវបានប្រតិបត្តិស្របគ្នាទេ។ មានតែស្នូលឡូជីខលជាច្រើនប៉ុណ្ណោះដែលនឹងត្រូវបានប្រតិបត្តិ (ខ្ញុំមាន 4) ។ ហើយអ្នកផ្សេងទៀតនឹងគ្រាន់តែដកធនធាន។ ដំណោះស្រាយមួយចំពោះបញ្ហានេះគឺលំនាំ async/await ។ គំនិតរបស់វាគឺថាមុខងារមួយមិនកាន់ខ្សែស្រឡាយទេប្រសិនបើវាត្រូវការរង់ចាំអ្វីមួយដើម្បីបន្ត។ ហើយនៅពេលដែលមានអ្វីមួយកើតឡើង វាបន្តការប្រតិបត្តិរបស់វាឡើងវិញ (ប៉ុន្តែមិនចាំបាច់នៅក្នុងខ្សែស្រឡាយដូចគ្នាទេ!) ក្នុងករណីរបស់យើង យើងនឹងរង់ចាំផ្លូវមួយ

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. តាមរយៈវា អ្នកអាចរង់ចាំវិធីសាស្ត្របញ្ចប់ បោះបង់វា និងអ្វីៗផ្សេងទៀតដែលអ្នកអាចធ្វើបានជាមួយ Task។ នៅខាងក្នុងវិធីសាស្ត្រ ម៉ាស៊ីនរដ្ឋគ្រប់គ្រងការប្រតិបត្តិ។ ចំណុចសំខាន់គឺថាប្រសិនបើគ្មានការពន្យារពេលទេនោះការប្រតិបត្តិគឺសមកាលកម្មហើយប្រសិនបើមាននោះខ្សែស្រឡាយត្រូវបានបញ្ចេញ។ សម្រាប់ការយល់ដឹងកាន់តែប្រសើរឡើង វាជាការប្រសើរជាងមុនក្នុងការមើលម៉ាស៊ីនរដ្ឋនេះ។ អ្នកអាចបង្កើតខ្សែសង្វាក់ទាំងនេះ async / await វិធីសាស្រ្ត។

តោះសាកល្បង។ ការងាររបស់ទស្សនវិទូ 100 នាក់នៅលើម៉ាស៊ីនដែលមានស្នូលឡូជីខលចំនួន 4 មានរយៈពេល 8 វិនាទី។ ដំណោះស្រាយពីមុនជាមួយ Monitor ប្រតិបត្តិតែ 4 threads ដំបូងប៉ុណ្ណោះ ហើយមិនបានប្រតិបត្តិអ្វីដែលនៅសល់ទាល់តែសោះ។ ខ្សែស្រលាយទាំង 4 នីមួយៗត្រូវបានទុកចោលប្រហែល 2ms ។ ហើយដំណោះស្រាយ async/await បានធ្វើទាំងអស់ 100 ដោយជាមធ្យម 6.8 វិនាទីរាល់ការរង់ចាំ។ ជាការពិតណាស់ នៅក្នុងប្រព័ន្ធពិត ការនៅទំនេររយៈពេល 6 វិនាទីគឺមិនអាចទទួលយកបានទេ ហើយវាជាការប្រសើរជាងកុំដំណើរការសំណើជាច្រើនតាមវិធីនេះ។ ដំណោះស្រាយជាមួយ Monitor ប្រែថាមិនអាចធ្វើមាត្រដ្ឋានបានទាល់តែសោះ។

សេចក្តីសន្និដ្ឋាន

ដូចដែលអ្នកអាចមើលឃើញពីឧទាហរណ៍តូចៗទាំងនេះ .NET គាំទ្រការបង្កើតសមកាលកម្មជាច្រើន។ ទោះយ៉ាងណាក៏ដោយ វាមិនតែងតែច្បាស់អំពីរបៀបប្រើពួកវានោះទេ។ ខ្ញុំសង្ឃឹមថាអត្ថបទនេះមានប្រយោជន៍។ យើង​កំពុង​បញ្ចប់​វា​សម្រាប់​ពេល​នេះ ប៉ុន្តែ​វា​នៅ​មាន​វត្ថុ​គួរ​ឱ្យ​ចាប់​អារម្មណ៍​ជា​ច្រើន​ដែល​នៅ​សេសសល់​ឧទាហរណ៍ ការ​ប្រមូល​សុវត្ថិភាព​ខ្សែ​បណ្ដាញ TPL Dataflow ការ​សរសេរ​កម្មវិធី​ប្រតិកម្ម គំរូ​ប្រតិបត្តិការ​កម្មវិធី​ជាដើម។

ប្រភព។

• ការមើលឃើញលំហូរ៖ កម្មវិធីមើលឃើញស្របគ្នា។
• MSDN៖ សែស្រឡាយ, លំនាំសរសេរកម្មវិធីអសមកាល និងច្រើនទៀត ល។
• [Richter] — CLR តាមរយៈ C#, Jeffrey Richter
• [Eric Lippert] - អំពីការចាក់សោ
• ប្រភព
• រូបភាព - "រាំក្នុងចំណោមដាវ", G. Semiradsky

ប្រភព: www.habr.com