Javaはプログラミングの重さを併発して鍵と読み書きをロックします。

重入錠
再ロックとは、名前の通り、再入力をサポートするロックであり、これは、スレッドがリソースに対して重複したロックをサポートすることができることを示しています。再入力とは、任意のスレッドがロックを取得した後、ロックされずに再びロックを取得することを意味し、この特性の実現には次の2つの問題を解決する必要がある。
1、スレッドは再度ロックを取得する。ロックは、ロックを取得するスレッドが現在占有されているスレッドかどうかを識別する必要があります。
2、ロックの最終リリース。スレッドはn回繰り返してロックを取得し、その後n回目にロックを解除した後、他のスレッドはこのロックを取得することができる。ロックの最終リリース要求ロックは、取得に対してカウントアップし、現在のロックが繰り返し取得された回数をカウントし、ロックが解除された場合はカウントダウンし、カウントが0に等しい場合はロックが解除されたことを示します。
Javaにはロックとロックが内蔵されています。
synchronizedの例

package com.home;
public class SynchronizedTest implements Runnable {
  public synchronized void method1() {
    System.out.println("method1   ，    !");
    method2();
  }
  public synchronized void method2() {
    System.out.println("method2   ，     !");
  }
  @Override
  public void run() {
    method1();
  }
  public static void main(String[] args) {
    SynchronizedTest st = new SynchronizedTest();
    new Thread(st).start();
    new Thread(st).start();
  }
}

ロックの実例

package com.home;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class LockTest implements Runnable {
  Lock lock = new ReentrantLock();
  public void method1() {
    lock.lock();
    System.out.println("method1   ，    !");
    method2();
    lock.unlock();
  }
  public void method2() {
    lock.lock();
    System.out.println("method2   ，     !");
    lock.unlock();
  }
  @Override
  public void run() {
    method1();
  }
  public static void main(String[] args) {
    LockTest lt = new LockTest();
    new Thread(lt).start();
    new Thread(lt).start();
  }
}

二つの例の最後の結果は正しいです。結果は以下の通りです。

method1   ，    !
method2   ，     !
method1   ，    !
method2   ，     !

再ロックができる最大の役割は、デッドロックを避けることです。
読み書きロック
読み書きロックはペア関連のロックを維持しています。読み取り専用の操作に使います。書き込み操作に使います。writerがない限り、読取ロックは複数のreaderスレッドで同時に保持されてもよい。書き込みロックは独り占めです。
再入力可能読み書きロックRentrant ReadWriteLock
Reentrantrant ReadWriteLockオブジェクトはリードロックと書き込みロックを取得するためのreadLock（）とwriteLock（）の方法を提供する。
読み取りロックは複数のreaderスレッドを同時に持つことができますが、書き込みロックは最大1つのwritterスレッドだけが持つことができます。
読み書きロックの場合：共有データを読み出す頻度は、修正共有データの周波数よりも遥かに大きいです。上記の場合、読み書きロックを使って共有リソースのアクセスを制御することで、同時性を高めることができます。
一方のスレッドが書き込みロックを持っている場合は、読み書きロックをもう持っていても良いです。反対に、もう一つのスレッドが読み取りロックを持っている場合は、その読み取りロックを解除する前に書き込みロックを持つことはできません。
書込みロックを呼び出すことができるnewCondation()メソッドは、この書込みロックと紐付けられたCondationオブジェクトを取得し、この場合は通常のインターロックと大差ないが、リードロックを呼び出すnewCondation()メソッドは異常を投げかける。
例

package com.home;
import java.util.Random;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
class ReadWrte {
  //     ，         ，          
  private int data;
  //      
  ReadWriteLock rwLock = new ReentrantReadWriteLock();
  /**
   *    ，   
   */
  public void get() {
    //   
    rwLock.readLock().lock();
    try {
      System.out.println(Thread.currentThread().getName() + ",Read!");
      Thread.sleep((long) Math.random() * 1000);
      System.out.println(Thread.currentThread().getName() + "       ：" +
        this.getData());
    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      rwLock.readLock().unlock();
    }
  }
  /**
   *    ，   
   *
   * @param data
   */
  public void put(int data) {
    //   
    rwLock.writeLock().lock();
    try {
      System.out.println(Thread.currentThread().getName() + ",Write!");
      Thread.sleep((long) Math.random() * 1000);
      this.setData(data);
      System.out.println(Thread.currentThread().getName() + "       ：" +
        this.getData());
    } catch (InterruptedException e) {
      e.printStackTrace();
    } finally {
      rwLock.writeLock().unlock();
    }
  }
  public int getData() {
    return data;
  }
  public void setData(int data) {
    this.data = data;
  }
}
/**
 *    
 *
 * @author itmyhome
 *
 */
public class ReadWriteLockTest {
  /**
   * @param args
   */
  public static void main(String[] args) {
    //   ReadWrte  
    final ReadWrte rw = new ReadWrte();
    for (int i = 0; i < 10; i++) {
      //      10    
      new Thread(new Runnable() {
          @Override
          public void run() {
            rw.get();
          }
        }).start();
      //      10    
      new Thread(new Runnable() {
          @Override
          public void run() {
            //        
            rw.put(new Random().nextInt(8));
          }
        }).start();
    }
  }
}

出力

Thread-0,Read!
Thread-4,Read!
Thread-8,Read!
Thread-12,Read!
Thread-0       ：0
Thread-4       ：0
Thread-8       ：0
Thread-12       ：0
Thread-19,Write!
Thread-19       ：5
Thread-7,Write!
Thread-7       ：7
Thread-3,Write!
Thread-3       ：4
Thread-16,Read!
Thread-16       ：4
Thread-11,Write!
Thread-11       ：0
Thread-15,Write!
Thread-15       ：5
Thread-2,Read!
Thread-2       ：5
Thread-17,Write!
Thread-17       ：2
Thread-6,Read!
Thread-6       ：2
Thread-1,Write!
Thread-1       ：5
Thread-13,Write!
Thread-13       ：4
Thread-9,Write!
Thread-9       ：7
Thread-5,Write!
Thread-5       ：2
Thread-10,Read!
Thread-10       ：2
Thread-18,Read!
Thread-14,Read!
Thread-18       ：2
Thread-14       ：2

図からは、複数のスレッドを同時に読むことができますが、1つのスレッドしか書き込みできません。つまり、データを書き込み、データを書き込みます。
締め括りをつける
以上はJavaのプログラミングの重さについてのロックと読み書きロックのすべての内容です。このサイトの他のテーマを参照してください。何か問題があったらいつでもメッセージを残してください。みなさんの応援に感謝します。