关于android:Java之戳中痛点之-synchronized-深度解析

概览：

简介：作用、位置、不管制并发的影响
用法：对象锁和类锁
多线程拜访同步办法的7种状况
性质：可重入、不可中断
原理：加解锁原理、可重入原理、可见性原理
缺点：效率低、不够灵便、无奈预判是否胜利获取到锁
如何抉择Lock或Synchronized
如何进步性能、JVM如何决定哪个线程获取锁
总结

后续会有代码演示，测试环境 JDK8、IDEA

一、简介

1、作用

可能保障在同一时刻最多只有一个线程执行该代码，以保障并发平安的成果。

2、位置

Synchronized是Java关键字，Java原生反对
最根本的互斥同步伎俩
并发编程的元老级别

3、不管制并发的影响

测试：两个线程同时a++，猜一下后果

package cn.jsonshare.java.base.synchronizedtest;  
  
/**  
 * 不应用synchronized,两个线程同时a++  
 *  
 * @author JSON  
 */  
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++;  
        }  
    }  
}

预期是20000，但屡次执行的后果都小于20000

二、用法：对象锁和类锁

1、对象锁

代码块模式：手动指定锁对象
办法锁模式：synchronized润饰办法，锁对象默认为this

package cn.jsonshare.java.base.synchronizedtest;  
  
/**  
 * 对象锁实例: 代码块模式  
 *  
 * @author JSON  
 */  
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  
 */  
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：synchronized加载static办法上

模式2：synchronized(*.class)代码块

package cn.jsonshare.java.base.synchronizedtest;  
  
/**  
 * 类锁：synchronized加载static办法上  
 *  
 * @author JSON  
 */  
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  
 */  
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种状况

两个线程同时拜访一个对象的雷同的synchronized办法
两个线程同时拜访两个对象的雷同的synchronized办法
两个线程同时拜访两个对象的雷同的static的synchronized办法
两个线程同时拜访同一对象的synchronized办法与非synchronized办法
两个线程拜访同一对象的不同的synchronized办法
两个线程同时拜访同一对象的static的synchronized办法与非static的synchronized办法
办法抛出异样后，会开释锁吗

认真看上面示例代码后果输入的后果，留神输入工夫距离，来预测论断

场景1：

package cn.jsonshare.java.base.synchronizedtest;  
  
/**  
 * 两个线程同时拜访一个对象的雷同的synchronized办法  
 *  
 * @author JSON  
 */  
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  
 */  
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  
 */  
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  
 */  
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  
 */  
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  
 */  
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  
 */  
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、两个线程同时拜访一个对象的雷同的synchronized办法

同一实例领有同一把锁，其余线程必然期待，程序执行

2、两个线程同时拜访两个对象的雷同的synchronized办法

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

3、两个线程同时拜访两个对象的雷同的static的synchronized办法

动态同步办法，是类锁，所有实例是同一把锁，其余线程必然期待，程序执行

4、两个线程同时拜访同一对象的synchronized办法与非synchronized办法

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

5、两个线程拜访同一对象的不同的synchronized办法

同一实例领有同一把锁，所以程序执行（阐明：锁的是this对象==同一把锁）

6、两个线程同时拜访同一对象的static的synchronized办法与非static的synchronized办法

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

7、办法抛出异样后，会开释锁吗

会主动开释锁，这里区别Lock，Lock须要显示的开释锁

3个核心思想：

一把锁只能同时被一个线程获取，没有拿到锁的线程必须期待（对应1、5的情景）
每个实例都对应有本人的一把锁，不同的实例之间互不影响；例外：锁对象是*.class以及synchronized被static润饰的时候，所有对象共用同一把锁（对应2、3、4、6情景）
无论是办法失常执行结束还是办法抛出异样，都会开释锁（对应7情景）

补充：

问题：目前进入到被synchronized润饰的办法，这个办法里边调用了非synchronized办法，是线程平安的吗？在公众号顶级架构师回复“架构整洁”，获取惊喜礼包。

package cn.jsonshare.java.base.synchronizedtest;  
  
/**  
 * 目前进入到被synchronized润饰的办法，这个办法里边调用了非synchronized办法，是线程平安的吗？  
 *  
 * @author JSON  
 */  
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典型的可重入锁：synchronized、ReentrantLock

益处：防止死锁，晋升封装性

粒度：线程而非调用

状况1：证实同一办法是可重入的
状况2：证实可重入不要求是同一办法
状况3：证实可重入不要求是同一类中的

2、不可中断

一旦这个锁被别的线程获取了，如果我当初想取得，我只能抉择期待或者阻塞，直到别的线程开释这个锁，如果别的线程永远不开释锁，那么我只能永远的期待上来。

相比之下，Lock类能够领有中断的能力，第一点：如果我感觉我期待的工夫太长了，有权中断当初曾经获取到锁的线程执行；第二点：如果我感觉我期待的工夫太长了不想再等了，也能够退出。

五、原理

1、加解锁原理（景象、机会、深刻JVM看字节码）

景象：每一个类的实例对应一把锁，每一个synchronized办法都必须首先取得调用该办法的类的实例的锁，方能执行，否则就会阻塞，办法执行实现或者抛出异样，锁被开释，被阻塞线程能力获取到该锁，执行。

获取和开释锁的机会：内置锁或监视器锁

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内存模型

线程A向线程B发送数据的过程（JMM管制）

synchronized关键字实现可见性：

被synchronized润饰，那么执行实现后，对对象所做的任何批改都要在开释锁之前，都要从线程内存写入到主内存，所以主内存中的数据是最新的。

六、缺点

1、效率低

1)、锁的开释状况少（线程执行实现或者异常情况开释）

2)、试图取得锁时不能设定超时（只能期待）

3)、不能中断一个正在试图取得锁的线程（不能中断）

2、不够灵便

加锁和开释的机会比拟繁多，每个锁仅有繁多的条件（某个对象），可能是不够的

比方：读写锁更灵便

3、无奈预判是否胜利获取到锁

七、常见问题

1、synchronized关键字留神点：

锁对象不能为空
作用域不宜过大
防止死锁

2、如何抉择Lock和synchronized关键字？

总结倡议（优先防止出错的准则）：

如果能够的话，尽量优先应用java.util.concurrent各种类（不须要思考同步工作，不容易出错）
优先应用synchronized，这样能够缩小编写代码的量，从而能够缩小出错率
若用到Lock或Condition独有的个性，才应用Lock或Condition

八、总结

一句话总结synchronized：

JVM会主动通过应用monitor来加锁和解锁，保障了同一时刻只有一个线程能够执行指定的代码，从而保障线程平安，同时具备可重入和不可中断的个性。

我的库存，须要的小伙伴请点击我的GitHub收费支付

关于android:Java之戳中痛点之-synchronized-深度解析

概览：

一、简介

1、作用

2、位置

3、不管制并发的影响

二、用法：对象锁和类锁

1、对象锁

2、类锁

总结：

补充：

四、性质

1、可重入

2、不可中断

五、原理

1、加解锁原理（景象、机会、深刻JVM看字节码）

2、可重入原理（加锁次数计数器）

3、可见性原理（内存模型）

六、缺点

1、效率低

2、不够灵便

3、无奈预判是否胜利获取到锁

七、常见问题

1、synchronized关键字留神点：

2、如何抉择Lock和synchronized关键字？

八、总结

评论

发表回复取消回复

更多文章

DDN HPC 存储硬件架构设计深度分析

探秘IO500：从Lustre并行文件系统出发，开启HPC存储性能新征程

苹果iOS打包的ipa应用无法安装？一篇文章带你了解可能的原因及排查方法

图解Golang：从零开始实现简易版过期LRU缓存

关于android:Java之戳中痛点之-synchronized-深度解析

概览：

一、简介

1、作用

2、位置

3、不管制并发的影响

二、用法：对象锁和类锁

1、对象锁

2、类锁

总结：

补充：

四、性质

1、可重入

2、不可中断

五、原理

1、加解锁原理（景象、机会、深刻JVM看字节码）

2、可重入原理（加锁次数计数器）

3、可见性原理（内存模型）

六、缺点

1、效率低

2、不够灵便

3、无奈预判是否胜利获取到锁

七、常见问题

1、synchronized关键字留神点：

2、如何抉择Lock和synchronized关键字？

八、总结

评论

发表回复 取消回复

更多文章

DDN HPC 存储硬件架构设计深度分析

探秘IO500：从Lustre并行文件系统出发，开启HPC存储性能新征程

苹果iOS打包的ipa应用无法安装？一篇文章带你了解可能的原因及排查方法

图解Golang：从零开始实现简易版过期LRU缓存

发表回复取消回复