食事哲学者問題

#include <chrono> #include <iostream> #include <mutex> #include <random> #include <semaphore> #include <thread> 
 
 
 
 
 

constexpr const size_t N = 5 ; // 哲学者（およびフォーク）の数enum class State { THINKING = 0 、// 哲学者は考えている THINKING HUNGRY = 1 、// 哲学者はフォークを手に入れようとしているEATING = 2 、// 哲学者は食べている};       
   

        
          
          


size_t inline left ( size_t i ) { // 両方のフォークが利用可能な哲学者 i の左隣の人の番号return ( i - 1 + N ) % N ; // i - 1 が負の場合に N が追加されます}    
  
    
            


size_t inline right ( size_t i ) { // 両方のフォークが利用可能な哲学者 i の右隣の番号return ( i + 1 ) % N ; }    
  
    
         


State state [ N ]; // 全員の both_forks_available 状態を追跡する配列   

std :: mutex critical_region_mtx ; // クリティカル領域の相互排他制御// (フォークの持ち上げと置き) std :: mutex output_mtx ; // 同期された cout (THINKING/HUNGRY/EATING ステータスの出力)   

   

// バイナリ セマフォの配列。哲学者ごとに 1 つのセマフォ。//
取得されたセマフォは、哲学者 i が 2 つのフォークを取得 (ブロック) したことを意味します
std :: binary_semaphore both_forks_available [ N ] { std :: binary_semaphore { 0 } , std :: binary_semaphore { 0 }, std :: binary_semaphore { 0 }, std :: binary_semaphore { 0 }, std :: binary_semaphore { 0 } }; 

     
     
    


size_t my_rand ( size_t min 、size_t max ) { static std :: mt19937 rnd ( std :: time ( nullptr )); return std :: universe_int_distribution <> ( min 、max )( rnd ); }     

      
      


void test ( size_t i ) // 哲学者 i が空腹で、両方の隣人が食べていない場合は、 eat { // i: 哲学者番号、0 から N-1 までif ( state [ i ] == State :: HUNGRY && state [ left ( i )] != State :: EATING && state [ right ( i )] != State :: EATING ) { state [ i ] = State :: EATING ; both_forks_available [ i ]. release (); // この eat セッションではフォークは不要になりました} }   

 
    
        
           
           
    
          
         
    


void think ( size_t i ) { size_t duration = my_rand ( 400 , 800 ); { std :: lock_guard < std :: mutex > lk ( output_mtx ); // 中断されないクリティカル セクション print std :: cout << i << " is thinking " << duration << "ms \n " ; } std :: this_thread :: sleep_for ( std :: chrono :: milliseconds ( duration )); }   

        
    
          
                
    
    


void take_forks ( size_t i ) { { std :: lock_guard < std :: mutex > lk { critical_region_mtx }; // クリティカル領域に入るstate [ i ] = State :: HUNGRY ; // 哲学者 i が State::HUNGRY であるという事実を記録する{ std :: lock_guard < std :: mutex > lk ( output_mtx ); // 中断のないクリティカル セクション print std :: cout << " \t\t " << i << " is State::HUNGRY \n " ; } test ( i ); // 2 つのフォーク (の許可) を取得しようとする} // クリティカル領域を終了するboth_forks_available [ i ]. acquire (); // フォークが取得されなかった場合はブロックする}  

    
           
            
        
              
                  
        
                                
                                       
      


void eat ( size_t i ) { size_tduration = my_rand ( 400 , 800 ); { std :: lock_guard < std :: mutex > lk ( output_mtx ); // 中断されない印刷のためのクリティカル セクションstd :: cout << " \t\ t \t\t " << i << " は " << duration << "msを消費しています\n " ; } std :: this_thread :: sleep_for ( std :: chrono :: milliseconds ( duration )); }  

        
    
          
                  
    
    


void put_forks ( size_t i ) { std :: lock_guard < std :: mutex > lk { critical_region_mtx }; // クリティカル領域に入るstate [ i ] = State :: THINKING ; // 哲学者は State::EATING を終了しましたtest ( left ( i )); // 左隣が食べられるようになったか確認test ( right ( i )); // 右隣が食べられるようになったか確認// 関数を終了してクリティカル領域を終了します}   
 
    
         
        
                   
                  
                                 


void philosopher ( size_t i ) { while ( true ) { // 永遠に繰り返すthink ( i ); // philosopher は State::THINKING であるtake_forks ( i ); // 2 つのフォークを取得するかブロックするeat ( i ); // おいしい、スパゲッティput_forks ( i ); // 両方のフォークをテーブルに戻し、隣の人が食べられるかどうか確認する} }  
  
      
                             
                     
                
                       
                 
    


int main () { std :: cout << "dp_14 \n " ;  
      

    std :: jthread t0 ([ & ] { philosopher ( 0 ); }); // [&] は、後続のラムダの外側にあるすべての変数を意味しますstd :: jthread t1 ([ & ] { philosopher ( 1 ) ; }); // 参照によってキャプチャされますstd :: jthread t2 ([ & ] { philosopher ( 2 ); }); std :: jthread t3 ([ & ] { philosopher ( 3 ); }); std :: jthread t4 ([ & ] { philosopher ( 4 ); }); }     
         
        
        
        

#include <iostream> #include <chrono> #include <mutex> #include <thread> #include <random> #include <ctime> 
 
 
 
 
 

名前空間std を使用します。  

int myrand ( int min , int max ) { static mt19937 rnd ( time ( nullptr )); return universe_int_distribution <> ( min , max )( rnd ); }     
    
   


void philosopher ( int ph , mutex & ma , mutex & mb , mutex & mo ) { for (;;) { // スレッドの終了を防ぐint duration = myrand ( 200 , 800 ); { // Block { } はロックのスコープを制限しますlock_guard < mutex > gmo ( mo ); cout << ph << " thinks " << duration << "ms \n " ; } this_thread :: sleep_for ( chrono :: milliseconds ( duration )); { lock_guard < mutex > gmo ( mo ); cout << " \t\t " << ph << " is hungry \n " ; } lock_guard < mutex > gma ( ma ); // sleep_for() ここで 2 番目のフォークを探す前の遅延を追加できますが、必須ではありません。lock_guard < mutex > gmb ( mb ); duration = myrand ( 200 , 800 ); { lock_guard < mutex > gmo ( mo ); cout << " \t\t\t\t " << ph << " eats " << duration << "ms \n " ; } this_thread :: sleep_for ( chrono :: milliseconds ( duration ) ); } }         
      
        
    
      
       
      
    
    
    
       
      
    
     
    
     
       
    
       
      
    
    
  


int main () { cout << "dining Philosophers C++11 with Resource hierarchy \n " ; mutex m1 , m2 , m3 , m4 , m5 ; // 5 つのフォークは 5 つのミューテックスですmutex mo ; // 適切な出力のため// 5 人の哲学者は 5 つのスレッドですthread t1 ([ & ] { philosopher ( 1 , m1 , m2 , mo );}); thread t2 ([ & ] { philosopher ( 2 , m2 , m3 , mo );}); thread t3 ([ & ] { philosopher ( 3 , m3 , m4 , mo );}); thread t4 ([ & ] { philosopher ( 4 , m4 , m5 , mo );}); thread t5 ( [ & ] { philosopher ( 5 , m1 , m5 , mo );}); // リソース階層を強制するt1.join ( ) ; // スレッドの終了を防ぐt2.join (); t3.join ( ) ; t4.join ( ) ; t5.join ( ) ; }