痛みのポイントでのJavaの突く - （8）同期の深さ分析

その他 2019-08-30 15:14:25 訪問数: null

概要：

  1. はじめに：役割、状態、同時実行制御には影響しません。
  2. 使用法：Objectクラスのロックとロック
  3. アクセスのマルチスレッドの同期方法の7種類
  4. 自然：リエントラント、無停電
  5. 原理：ロックおよびロック解除の原則、リエントラント原則、可視性の原則
  6. 欠陥：非効率的な、柔軟性のない、取得に成功したロックするかどうかを予測することはできません
  7. ロックを選択するか、または同期する方法
  8. パフォーマンスを向上させるために、どのように、JVMはどのようにロックを獲得するスレッドが決定します
  9. 概要

ありますフォローアップのコードは、テスト環境JDK8、IDEAを実証

I.はじめに

1、の役割

一つだけスレッドの最大値が同時にコードを実行することを保証するために== ==同時効果の安全性を確保します。

2、状態

  • synchronizedキーワードは、Java、Javaのネイティブサポートであります
  • 最も基本的な同期は相互に排他的意味します
  • 並行プログラミングのベテランレベル

3、同時実行制御には影響しません。

テスト：同時に2つのスレッド++は、どのような結果を推測します

package cn.jsonshare.java.base.synchronizedtest;

/**
 * 不使用synchronized,两个线程同时a++
 *
 * @author JSON
 * @date 2019-08-29
 */
public class SynchronizedTest1 implements Runnable{
    static SynchronizedTest1 st = new SynchronizedTest1();

    static int a = 0;

    /**
     * 不使用synchronized,两个线程同时a++
     */
    public static void main(String[] args) throws Exception{
        Thread t1 = new Thread(st);
        Thread t2 = new Thread(st);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(a);
    }

    @Override
    public void run(){
        for(int i=0; i<10000; i++){
            a++;
        }
    }
}

20,000と期待が、結果は20,000未満の複数回あるさ

10108
11526
10736
...

第二に、使用：クラスとオブジェクトロックロック

図1に示すように、オブジェクトロック

  • ブロック形式：手動で指定されたロックオブジェクト
  • ロック方法フォーム：同期修飾法、ロックはこれにデフォルト値をオブジェクト
package cn.jsonshare.java.base.synchronizedtest;

/**
 * 对象锁实例: 代码块形式
 *
 * @author JSON
 * @date 2019-08-29
 */
public class SynchronizedTest2 implements Runnable{
    static SynchronizedTest2 st = new SynchronizedTest2();

    public static void main(String[] args) {
        Thread t1 = new Thread(st);
        Thread t2 = new Thread(st);
        t1.start();
        t2.start();
        while(t1.isAlive() || t2.isAlive()){

        }
        System.out.println("run over");

    }

    @Override
    public void run(){
        synchronized (this){
            System.out.println("开始执行:" + Thread.currentThread().getName());
            try {
                // 模拟执行内容
                Thread.sleep(3000);
            }catch (Exception e){
                e.printStackTrace();
            }
            System.out.println("执行结束:" + Thread.currentThread().getName());
        }
    }
}

package cn.jsonshare.java.base.synchronizedtest;

/**
 * 对象锁实例：synchronized方法
 * @author JSON
 * @date 2019-08-29
 */
public class SynchronizedTest3 implements Runnable{
    static SynchronizedTest3 st = new SynchronizedTest3();

    public static void main(String[] args) throws Exception{
        Thread t1 = new Thread(st);
        Thread t2 = new Thread(st);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("run over");
    }

    @Override
    public void run(){
        method();
    }

    public synchronized void method(){
        System.out.println("开始执行:" + Thread.currentThread().getName());
        try {
            // 模拟执行内容
            Thread.sleep(3000);
        }catch (Exception e){
            e.printStackTrace();
        }
        System.out.println("执行结束:" + Thread.currentThread().getName());
    }
}

結果：

开始执行:Thread-0
执行结束:Thread-0
开始执行:Thread-1
执行结束:Thread-1
run over

2、ロック

==コンセプト：Javaクラスは複数のオブジェクトがあるかもしれませんが、唯一のClassオブジェクト==

==自然：いわゆるクラスロックが、ロックClassオブジェクトのみ==

==使い方と有効性：クラスのロックが唯一、同時にオブジェクトにすることができてい==

様式1：静的メソッドの同期ロード

様式2：（。*クラス）同期ブロック

package cn.jsonshare.java.base.synchronizedtest;

/**
 * 类锁：synchronized加载static方法上
 *
 * @author JSON
 * @date 2019-08-29
 */
public class SynchronizedTest4 implements Runnable{

    static SynchronizedTest4 st1 = new SynchronizedTest4();
    static SynchronizedTest4 st2 = new SynchronizedTest4();

    public static void main(String[] args) throws Exception{
        Thread t1 = new Thread(st1);
        Thread t2 = new Thread(st2);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("run over");
    }

    @Override
    public void run(){
        method();
    }

    public static synchronized void method(){
        System.out.println("开始执行:" + Thread.currentThread().getName());
        try {
            // 模拟执行内容
            Thread.sleep(3000);
        }catch (Exception e){
            e.printStackTrace();
        }
        System.out.println("执行结束:" + Thread.currentThread().getName());
    }
}


package cn.jsonshare.java.base.synchronizedtest;

/**
 * 类锁：synchronized(*.class)代码块
 *
 * @author JSON
 * @date 2019-08-29
 */
public class SynchronizedTest5 implements Runnable{
    static SynchronizedTest4 st1 = new SynchronizedTest4();
    static SynchronizedTest4 st2 = new SynchronizedTest4();

    public static void main(String[] args) throws Exception{
        Thread t1 = new Thread(st1);
        Thread t2 = new Thread(st2);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("run over");
    }

    @Override
    public void run(){
        method();
    }

    public void method(){
        synchronized(SynchronizedTest5.class){
            System.out.println("开始执行:" + Thread.currentThread().getName());
            try {
                // 模拟执行内容
                Thread.sleep(3000);
            }catch (Exception e){
                e.printStackTrace();
            }
            System.out.println("执行结束:" + Thread.currentThread().getName());
        }
    }
}

結果：

开始执行:Thread-0
执行结束:Thread-0
开始执行:Thread-1
执行结束:Thread-1
run over

第三に、マルチスレッドアクセスを同期方法7例

  1. 2つのスレッドが同時に同じ同期メソッドのオブジェクトにアクセス
  2. 同じ同期メソッド2つのスレッドが同時に2つのオブジェクトをアクセスします
  3. 2つのスレッドが同時に同じ静的同期方法の2つのオブジェクトにアクセス
  4. 同期メソッド2つのスレッドが同時に非同期メソッドと同じオブジェクトにアクセス
  5. 同期二つのスレッドの異なる方法が同じオブジェクトにアクセス
  6. 2つのスレッドが同時に同じオブジェクトが静的メソッドと非静的同期方式を同期されるアクセス
  7. メソッドが例外をスローした後、それはロックを解除します

予後の結論への出力の次の例は、近いコード結果を結果を参照してください、出力時間間隔の注意

シナリオ1：

package cn.jsonshare.java.base.synchronizedtest;

/**
 * 两个线程同时访问一个对象的相同的synchronized方法
 *
 * @author JSON
 * @date 2019-08-29
 */
public class SynchronizedScene1 implements Runnable{
    static SynchronizedScene1 ss = new SynchronizedScene1();

    public static void main(String[] args) throws Exception{
        Thread t1 = new Thread(ss);
        Thread t2 = new Thread(ss);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("run over");
    }

    @Override
    public void run(){
        method();
    }

    public synchronized void method(){
        System.out.println("开始执行:" + Thread.currentThread().getName());
        try {
            // 模拟执行内容
            Thread.sleep(3000);
        }catch (Exception e){
            e.printStackTrace();
        }
        System.out.println("执行结束:" + Thread.currentThread().getName());
    }
}

シナリオ2：

package cn.jsonshare.java.base.synchronizedtest;

/**
 * 两个线程同时访问两个对象的相同的synchronized方法
 *
 * @author JSON
 * @date 2019-08-29
 */
public class SynchronizedScene2 implements Runnable{
    static SynchronizedScene2 ss1 = new SynchronizedScene2();
    static SynchronizedScene2 ss2 = new SynchronizedScene2();

    public static void main(String[] args) throws Exception{
        Thread t1 = new Thread(ss1);
        Thread t2 = new Thread(ss2);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("run over");
    }

    @Override
    public void run(){
        method();
    }

    public synchronized void method(){
        System.out.println("开始执行:" + Thread.currentThread().getName());
        try {
            // 模拟执行内容
            Thread.sleep(3000);
        }catch (Exception e){
            e.printStackTrace();
        }
        System.out.println("执行结束:" + Thread.currentThread().getName());
    }
}

シナリオ3：

package cn.jsonshare.java.base.synchronizedtest;

/**
 * 两个线程同时访问两个对象的相同的static的synchronized方法
 *
 * @author JSON
 * @date 2019-08-29
 */
public class SynchronizedScene3 implements Runnable{
    static SynchronizedScene3 ss1 = new SynchronizedScene3();
    static SynchronizedScene3 ss2 = new SynchronizedScene3();

    public static void main(String[] args) throws Exception{
        Thread t1 = new Thread(ss1);
        Thread t2 = new Thread(ss2);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("run over");
    }

    @Override
    public void run(){
        method();
    }

    public synchronized static void method(){
        System.out.println("开始执行:" + Thread.currentThread().getName());
        try {
            // 模拟执行内容
            Thread.sleep(3000);
        }catch (Exception e){
            e.printStackTrace();
        }
        System.out.println("执行结束:" + Thread.currentThread().getName());
    }
}

シナリオ4：

package cn.jsonshare.java.base.synchronizedtest;

/**
 * 两个线程同时访问同一对象的synchronized方法与非synchronized方法
 *
 * @author JSON
 * @date 2019-08-29
 */
public class SynchronizedScene4 implements Runnable{
    static SynchronizedScene4 ss1 = new SynchronizedScene4();

    public static void main(String[] args) throws Exception{
        Thread t1 = new Thread(ss1);
        Thread t2 = new Thread(ss1);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("run over");
    }

    @Override
    public void run(){
        // 模拟两个线程同时访问 synchronized方法与非synchronized方法
        if(Thread.currentThread().getName().equals("Thread-0")){
            method1();
        }else{
            method2();
        }
    }

    public void method1(){
        System.out.println("method1开始执行:" + Thread.currentThread().getName());
        try {
            // 模拟执行内容
            Thread.sleep(3000);
        }catch (Exception e){
            e.printStackTrace();
        }
        System.out.println("method1执行结束:" + Thread.currentThread().getName());
    }

    public synchronized void method2(){
        System.out.println("method2开始执行:" + Thread.currentThread().getName());
        try {
            // 模拟执行内容
            Thread.sleep(3000);
        }catch (Exception e){
            e.printStackTrace();
        }
        System.out.println("method2执行结束:" + Thread.currentThread().getName());
    }
}

シナリオ5：

package cn.jsonshare.java.base.synchronizedtest;

/**
 * 两个线程访问同一对象的不同的synchronized方法
 *
 * @author JSON
 * @date 2019-08-29
 */
public class SynchronizedScene5 implements Runnable{
    static SynchronizedScene5 ss1 = new SynchronizedScene5();

    public static void main(String[] args) throws Exception{
        Thread t1 = new Thread(ss1);
        Thread t2 = new Thread(ss1);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("run over");
    }

    @Override
    public void run(){
        // 模拟两个线程同时访问不同的synchronized方法
        if(Thread.currentThread().getName().equals("Thread-0")){
            method1();
        }else{
            method2();
        }
    }

    public synchronized void method1(){
        System.out.println("method1开始执行:" + Thread.currentThread().getName());
        try {
            // 模拟执行内容
            Thread.sleep(3000);
        }catch (Exception e){
            e.printStackTrace();
        }
        System.out.println("method1执行结束:" + Thread.currentThread().getName());
    }

    public synchronized void method2(){
        System.out.println("method2开始执行:" + Thread.currentThread().getName());
        try {
            // 模拟执行内容
            Thread.sleep(3000);
        }catch (Exception e){
            e.printStackTrace();
        }
        System.out.println("method2执行结束:" + Thread.currentThread().getName());
    }
}

シナリオ6：

package cn.jsonshare.java.base.synchronizedtest;

/**
 * 两个线程同时访问同一对象的static的synchronized方法与非static的synchronized方法
 *
 * @author JSON
 * @date 2019-08-29
 */
public class SynchronizedScene6 implements Runnable{
    static SynchronizedScene6 ss1 = new SynchronizedScene6();

    public static void main(String[] args) throws Exception{
        Thread t1 = new Thread(ss1);
        Thread t2 = new Thread(ss1);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("run over");
    }

    @Override
    public void run(){
        // 模拟两个线程同时访问static的synchronized方法与非static的synchronized方法
        if(Thread.currentThread().getName().equals("Thread-0")){
            method1();
        }else{
            method2();
        }
    }

    public static synchronized void method1(){
        System.out.println("method1开始执行:" + Thread.currentThread().getName());
        try {
            // 模拟执行内容
            Thread.sleep(3000);
        }catch (Exception e){
            e.printStackTrace();
        }
        System.out.println("method1执行结束:" + Thread.currentThread().getName());
    }

    public synchronized void method2(){
        System.out.println("method2开始执行:" + Thread.currentThread().getName());
        try {
            // 模拟执行内容
            Thread.sleep(3000);
        }catch (Exception e){
            e.printStackTrace();
        }
        System.out.println("method2执行结束:" + Thread.currentThread().getName());
    }
}

シーン7：

package cn.jsonshare.java.base.synchronizedtest;

/**
 * 方法抛出异常后，会释放锁吗
 *
 * @author JSON
 * @date 2019-08-29
 */
public class SynchronizedScene7 implements Runnable{
    static SynchronizedScene7 ss1 = new SynchronizedScene7();

    public static void main(String[] args) throws Exception{
        Thread t1 = new Thread(ss1);
        Thread t2 = new Thread(ss1);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("run over");
    }

    @Override
    public void run(){
        method1();
    }

    public synchronized void method1(){
        System.out.println("method1开始执行:" + Thread.currentThread().getName());
        try {
            // 模拟执行内容
            Thread.sleep(3000);
        }catch (Exception e){
            e.printStackTrace();
        }
        // 模拟异常
        throw new RuntimeException();
        //System.out.println("method1执行结束:" + Thread.currentThread().getName());
    }
}
要約：

図1に示すように、2つのスレッドが同時に同じ同期メソッドのオブジェクトへのアクセス

同一实例拥有同一把锁，其他线程必然等待，顺序执行

図2に示すように、2つのスレッドが同時に同じ同期方法二つのオブジェクトにアクセスします

不同的实例拥有的锁是不同的，所以不影响，并行执行

図3は、2つのスレッドが同時に二つのオブジェクトの同じ同期静的メソッドにアクセス

静态同步方法，是类锁，所有实例是同一把锁，其他线程必然等待，顺序执行

図4は、同期メソッド2つのスレッドが同時に非同期メソッドと同じオブジェクトにアクセス

非synchronized方法不受影响，并行执行

図5に示すように、2つのスレッドが同期の異なる方法の同じオブジェクトにアクセスします

同一实例拥有同一把锁，所以顺序执行（说明：锁的是this对象==同一把锁）

図6に示すように、2つのスレッドが同時にアクセス同じオブジェクトは、静的な方法および非静的同期メソッドを同期さ

static同步方法是类锁，非static是对象锁，原理上是不同的锁，所以不受影响，并行执行

7、メソッドが例外をスローし、それがロックを解除します

会自动释放锁，这里区别Lock，Lock需要显示的释放锁
3つのコアのアイデア：

1、ロックはロック・スレッドは、（1,5シナリオに相当）待たなければなりません取得していない一つのスレッドを同時に取得し、することができ

図2に示すように、独立の異なるインスタンス間で互いのロックを所有する対応する各インスタンス。

例外：锁对象是*.class以及synchronized被static修饰的时候，所有对象共用同一把锁（对应2、3、4、6情景）

3、それが終了するか、通常の方法は、例外をスローするかどうか、（7シナリオに対応する）ロックを解除します

彼は加えました：

質問：現在、修正方法に同期され、この方法は、非同期メソッドの内部で呼び出すスレッドセーフですか？

package cn.jsonshare.java.base.synchronizedtest;

/**
 * 目前进入到被synchronized修饰的方法，这个方法里边调用了非synchronized方法，是线程安全的吗？
 *
 * @author JSON
 * @date 2019-08-29
 */
public class SynchronizedScene8 {
    public static void main(String[] args) {
        new Thread(() -> {
            method1();
        }).start();

        new Thread(() -> {
            method1();
        }).start();
    }

    public static synchronized void method1() {
        method2();
    }

    private static void method2() {
        System.out.println(Thread.currentThread().getName() + "进入非Synchronized方法");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(Thread.currentThread().getName() + "结束非Synchronized方法");
    }
}

結論：これは、スレッドセーフであります

第四に、の性質

1、リエントラント

外側の関数の後にロックを取得するために同一のスレッドを参照して、内側の関数を直接再びロックを獲得

典型的なJavaのリエントラントロック：同期、ReentrantLockの

利点：カプセル化を強化、デッドロックを回避

サイズ：スレッドではなく、呼び出し

情况1：证明同一方法是可重入的
情况2：证明可重入不要求是同一方法
情况3：证明可重入不要求是同一类中的

2、中断することはできません

ロックが別のスレッドによって獲得された後、別のスレッドがロックを解除することはありません場合、私は今取得したい場合、私は唯一の他のスレッドがロックを解放するまで待つか、ブロックするかを選択することができ、その後、私はいつも待つことができます。

これとは対照的に、ロックのクラスは、最初のポイントを中断する能力を持つことができます：私はあまりにも長い間待っていれば、今実行スレッドをロックするために中断する権利を取得したと思います。第二の点：私は待っていれば私は思いますあなたも終了することができ、あまりにも長く待つ必要はありません。

第五に、の原則

1、プラスロック解除原理（現象、タイミング、深いルックJVMバイトコード）

現象：ロックに対応するクラスのすべてのインスタンス、各同期方法は、第1のクラスのインスタンスのロックを取得する必要がありそうでなければ妨害、実行するために、メソッドを呼び出し、または完全な実行方法は、例外をスローし、ロックが解除されます、スレッドが実行するロックを取得することができるブロックされました。

取得し、ロックを解除するタイミング：内部ロックまたはモニタのロック

package cn.jsonshare.java.base.synchronizedtest;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * method1 等价于 method2
 *
 * @author JSON
 * @date 2019-08-29
 */
public class SynchronizedToLock1 {
    Lock lock = new ReentrantLock();

    public synchronized void method1(){
        System.out.println("执行method1");
    }

    public void method2(){
        lock.lock();
        try {
            System.out.println("执行method2");
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        SynchronizedToLock1 sl = new SynchronizedToLock1();

        // method1 等价于 method2
        sl.method1();
        sl.method2();
    }
}

綿密でJVMバイトコードを見てみましょう。

...
monitorenter指令
...
monitorexit指令
...

2、リエントラント（ロック数カウンタ）の原理

JVMがロックされるオブジェクトの数を追跡するための責任があります

同じスレッドが再び、このオブジェクトのロックを獲得するたびにカウントが1になったときにオブジェクトをロックする最初のスレッドは、カウントがインクリメントされ

タスクが脱退するたびにカウントが0であるとき、カウントダウンし、ロックが完全に解放されます

図3に示すように、視認性原理（メモリモデル）

Javaのメモリモデル

アバター

工程（JMMコントロール）スレッド、スレッドBにデータを送信します

アバター

== synchronizedキーワードは、可視性を実現：==

変更が同期されているので、実装が完了した後、すべての変更は、メインメモリ内のデータが最新のものである、スレッドはメインメモリにメモリから書き込む必要があり、ロックを解除する前にオブジェクトを参照すべきです。

第六に、欠陥

1、非効率

1）（スレッドの実行が完了または異常が放出される）より少ないロックケースを解放します

2））のロックを取得しようとしたとき（待機するようにタイムアウトを設定することはできません

3）ロックを取得しようとしているスレッドを中断することはできません（中断されていません）

2、十分に柔軟ではありません

ロックおよび解除時間比較的単純な、それぞれが、それは十分ではないかもしれない唯一の条件（オブジェクト）ロック

たとえば：読み書きより柔軟なロック

図3は、ロックが正常に取得されたかどうかを予測することはできません

七つのよくある質問

1、synchronizedキーワードの使用上の注意：

  1. ロックオブジェクトは空にすることはできません
  2. 適用範囲が大きすぎてはなりません
  3. デッドロックを回避

2、どのようにロックとsynchronizedキーワードを選択するには？

推薦の概要（エラーを回避する優先の原則）：

  1. 可能であれば、java.util.concurrentの様々な優先度クラスを使用しないようにしてみてください（検討する必要性を全く同期、エラーが発生しやすいです）
  2. 好ましくは、誤り率を低減することができる、符号量を低減することができるように、同期に使用
  3. ロックや条件は、固有の特性を使用した場合、唯一のロックまたは条件を使用

八、要約

同期述べます：

自動的にモニターを使用してロック及びロック解除するJVM、唯一のスレッドがスレッドの安全性を確保するために指定されたコードを実行するだけでなく、リエントラントと遮断特性を有することができ、同じ時間を確保します。

おすすめ

転載: www.cnblogs.com/JsonShare/p/11433302.html
おすすめ
ランキング
1028リストの並べ替え（25分）
pom.xml ファイルがアイデアによって認識されません
単一テーブルのデータのSQLクエリ組み合わせ（C）
gitのinitとgitの初期化-bare違いやソースファイルなしで問題を解決するには、WWWで見ることができません
BULLETエンジンスターター - コンパイル（cmakeのとPreMake）
vue-crossドメインの問題
ThingsBoard フロントエンド プロジェクトの組み込みコンポーネント開発
単元の学習過程での難しい問題とその解決策 -----(1)
MongoDBのデータは、クライアントで表示することができますが、作業はコマンドラインでlinuxでありません
How to check your PYTHONPATH environment variable
アーカイブ
もっと
2024-06-02(0)
2024-06-01(1)
2024-05-31(1)
2024-05-30(0)
2024-05-29(1)
2024-05-28(0)
2024-05-27(1)
2024-05-26(0)
2024-05-25(1)
2024-05-24(11)

コードワールド

© 2018 codetd.com