Java 実装と読み取り/書き込みロックアルゴリズムの考え方

問題の背景: 複数のスレッドが共有リソースへの読み取りおよび書き込みアクセスを実行します。書き込みスレッドは相互に排他的である必要があり、読み取りスレッドと書き込みスレッドは相互に排他的である必要があり、読み取りスレッドは相互に排他的である必要はありません。

以前、私は Java 5 の強化された並行機能に関する張先生の授業に参加しました。読み取り/書き込みロックの問題は、java.util.concurrent.locks の ReadWriteLock を使用すると簡単に解決できます。 ReadWriteLock がないと synchronized だけで何ができるのかと考えています。確かにその方が面倒です。

1. 張先生が教えたオブジェクト指向設計のアイデアを組み合わせて、まず書き込みメソッドと読み取りメソッドをカプセル化する共有リソースとしてビジネスクラス Business を設計します。

2. write は相互に排他的である必要があるため、 synchronized を直接定義します。

3. 読み取りは相互に排他的である必要はないため、読み取りを直接同期として定義することはできません。ただし、書き込みと読み取りは相互に排他的である必要があります。これを制御するにはどうすればよいですか? 考えられる 1 つの方法は、読み取りに synchronized(this){} を追加し、readThreads カウンターをセマフォとして定義することです。次のような状況を想定しています。

read[m]はスレッドの読み取りメソッドを表します。

write[n] 上記と同じ

1> read[m]がsynchronized(this){readThreads++;}を実行すると、write[n]が来て、write[n]は自身のsynchronizedによってブロックされます。

2> read[m]が何かを実行しているとき（この時点ではロックなし）、write[n]が来て、readThreads!=0であるため待機を余儀なくされます。

3> read[m]が終了するたびに、待機中のwrite[n]に通知されます。しかし、他の読み取りがあることがわかった場合、write[n]は再び無力に待機することしかできません。

4> readThreads==0 で、notifyAll が呼び出されると、read[m] と write[n] が CPU を奪い合います。write[n] が再度失敗すると、1> または 3> が表示されます。成功すると、次のようになります。

5> write[n]が起動して待機中にロックを占有すると、read[m]はsynchronized(this){readThreads++;}でブロックされます。

6>ブロックされたwrite[n]がロックを占有している場合、read[m]はsynchronized(this){readThreads++;}でブロックされます。

上記から、読み取りと書き込みは相互に排他的であると思われます。

4. 実装の詳細は次のとおりです。<誤りがあれば指摘してください>

パッケージ通信;
 java.util.Randomをインポートします。 
 
公共 クラスReadWriteLockTest { 
        公共 静的  void main(String[] args){ 
                最終的なビジネスbusiness =新しいビジネス(); 
                  
                 // 4 つのスレッドを開始します。2 つは読み取り、2 つは書き込みです。  
                 ( int i = 1 ; i <= 2 ; i++)の場合{ 
                                新しいスレッド(新しいRunnable(){ 
                                        公共  void実行() { 
                                                 ( int j = 1 ; j < 1000 ; j++)の場合{
                                                        ビジネス.read(); 
                                                        試す{
                                                                スレッド.スリープ( 900 );
                                                        }キャッチ(InterruptedException e) {
                                                                e.printStackTrace();
                                                        }
                                                }
                                        }
                                }）。始める（）; 
                                  
                                新しいスレッド(新しいRunnable(){ 
                                        公共  void実行() {
                                                ランダム r = new Random(); 
                                                 ( int j = 1 ; j < 1000 ; j++)の場合{ 
                                                         int i = r.nextInt( 100 );
                                                        ビジネス.write(i); 
                                                        試す{
                                                                スレッド.スリープ( 1000 );
                                                        }キャッチ(InterruptedException e) {
                                                                e.printStackTrace();
                                                        }
                                                }
                                        }
                                }）。始める（）;
                } 
                  
        } 
          
 }
 //カプセル化されたビジネスクラス 
クラスビジネス{ 
        プライベート  int data = 0 ; // 共有リソース属性 
        プライベート  int readThreads = 0 ; //スレッド番号を読み取る 
         //プライベートブール値 isWriting = false;  
         //writeを実行するかどうかは後で判明したが、writeがロックを獲得すると、すべてのreadはsynchronized(this){}でブロックされ、waitを実行する機会はない。  
        公共  void読み取り(){ 
                同期された（これ）{ 
                         /*while(isWriting){
                                試す {
                                        これを待機します。
                                } キャッチ (InterruptedException e) {
                                        // TODO 自動生成されたキャッチブロック
                                        e.printStackTrace();
                                }
                        }*/   
                         //readThreads がロックされていない場合、読み取りと書き込みが相互に排他的でない可能性がわずかながら発生し、スレッドのセキュリティが損なわれます。  
                        スレッドを読み取ります++; 
                          
                } 
                  
                System.out.println(Thread.currentThread().getName()+ "読み取り開始" );
                System.out.println(Thread.currentThread().getName()+ " 読み取り: " +データ);
                System.out.println(Thread.currentThread().getName()+ " 読み取り完了" ); 
                          
                同期された（これ）{
                        スレッドを読み取ります--; 
                        これは.notifyAll() です。
                }
        } 
          
        公共 同期した  void書き込み( int i){ 
                 while (readThreads != 0 ){ //読み取りが何かを行っている状態になると書き込みが来るので、まず待つ必要があります 
                        試す{ 
                                これは.wait();
                        }キャッチ(InterruptedException e) {
                                e.printStackTrace();
                        }
                } 
                 //isWriting = true;  
                System.out.println(Thread.currentThread().getName()+ " 書き込み開始" );
                データ = i;
                System.out.println(Thread.currentThread().getName()+ " 書き込み: " +i);
                System.out.println(Thread.currentThread().getName()+ " 上書き" ); 
                 //isWriting = false;  
                これは.notifyAll() です。
        }
 }