并发安全工具类（1）：synchronized

快来打我* 2023-06-28 06:17 34阅读 0赞

>  *  [https://www.imooc.com/learn/1086][https_www.imooc.com_learn_1086]
>  *  脑图：[http://naotu.baidu.com/file/f887c699482a945a02d774582e52e782?token=fce1efb54ad492d4][http_naotu.baidu.com_file_f887c699482a945a02d774582e52e782_token_fce1efb54ad492d4]
>  *  monitor：[https://zhuanlan.zhihu.com/p/86607654][https_zhuanlan.zhihu.com_p_86607654]

> 依赖JVM实现

--------------------

# 1 不使用并发手段带来的问题 #

>  得不到想要的值

>  修复上面的bug

public class DisappearRequest implements Runnable {
        static DisappearRequest instance = new DisappearRequest();
        static int i = 0;
        public static void main(String[] args) throws InterruptedException {
            Thread t1 = new Thread(instance);
            Thread t2 = new Thread(instance);
            t1.start();
            t2.start();
            t1.join();
            t2.join();
            System.out.println(i);
        }
        //方法一
        //@Override
        //public synchronized void run() {
        //    for (int j = 0; j < 100000; j++) {
        //        i++;
        //    }
        //}
    
        //方法二
        //@Override
        //public void run() {
        //    synchronized (this){
        //        for (int j = 0; j < 100000; j++) {
        //            i++;
        //        }
        //    }
        //}
    
        //方法三
        //@Override
        //public void run() {
        //    method();
        //}
        //public synchronized void method(){
        //    for (int j = 0; j < 100000; j++) {
        //        i++;
        //    }
        //}
        
        //方法四
        @Override
        public void run() {
            synchronized (DisappearRequest.class) {
                for (int j = 0; j < 100000; j++) {
                    i++;
                }
            }
        }
    }

--------------------

# 2 synchronized用法 #

> synchronized不属于方法声明的一部分，是无法继承的

>  *  修饰代码块：大括号括起来的代码，作用于调用的对象
>  *  修饰方法：整个方法，作用于调用的对象
>  *  修饰静态方法：整个静态方法，作用于所有对象
>  *  修饰类：括号括起来的部分，作用于所有对象

>  *  **对象锁：**包括方法锁（**默认锁对象为this当前实例对象**）和同步代码块锁（**自己指定锁对象**）
>  *  **类锁：**指 synchronized修饰静态的方法或指定锁为Class对象。

## 2.1 对象锁的形式1-同步代码块 ##

public class SynchronizedObjectCodeBlock implements Runnable {
        static SynchronizedObjectCodeBlock instance = new SynchronizedObjectCodeBlock();
        Object lock = new Object();
        public static void main(String[] args) {
            Thread t1 = new Thread(instance);
            Thread t2 = new Thread(instance);
            t1.start();
            t2.start();
            while (t1.isAlive() || t2.isAlive()) {
            }
            System.out.println("finished");
        }
        @Override
        public void run() {
            //synchronized (lock) {
            synchronized (this) {
                System.out.println("我是对象锁的代码快形式，我叫" + Thread.currentThread().getName());
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "运行结束");
            }
        }
    }

## 2.2 对象锁的形式2-普通方法锁 ##

public class SynchronizedObjectMethod implements Runnable{
        static SynchronizedObjectMethod instance = new SynchronizedObjectMethod();
        public static void main(String[] args) {
            Thread t1 = new Thread(instance);
            Thread t2 = new Thread(instance);
            t1.start();
            t2.start();
            while (t1.isAlive() || t2.isAlive()) { }
            System.out.println("finished");
        }
        @Override
        public void run() {
            method();
        }
        /**
         * 锁对象默认为this
         */
        public synchronized void method(){
            System.out.println("我是对象锁的方法修饰符形式，我叫"+Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "运行结束");
        }
    }

public class Main {
        // m1 m2 都被锁住了
        public synchronized void write() {
            System.out.println(Thread.currentThread().getName() + " call write.");
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException ignored) {
            }
            red();
        }
        public synchronized void red() {
            System.out.println(Thread.currentThread().getName() + " call red.");
        }
        public static void main(String[] args) throws InterruptedException {
            Main main = new Main();
            new Thread(main::write, "AAA").start();
            new Thread(main::red, "BBB").start();
            //AAA call write .
            //AAA call red .
            //BBB call red .
        }
    }

## 2.3 类锁的形式1-静态方法锁 ##

public class SynchronizedClassStatic implements Runnable{
        static SynchronizedClassStatic instance1 = new SynchronizedClassStatic();
        static SynchronizedClassStatic instance2 = new SynchronizedClassStatic();
        public static void main(String[] args) {
            Thread t1 = new Thread(instance1);
            Thread t2 = new Thread(instance2);
            t1.start();
            t2.start();
            while (t1.isAlive() || t2.isAlive()) { }
            System.out.println("finished");
        }
        @Override
        public void run() {
            method();
        }
        public static synchronized void method(){
            System.out.println("我是类锁的第一种形式：static形式，我叫"+Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "运行结束");
        }
    }

## 2.4 类锁的形式2-class ##

public class SynchronizedClassClass implements Runnable{
        static SynchronizedClassClass instance1 = new SynchronizedClassClass();
        static SynchronizedClassClass instance2 = new SynchronizedClassClass();
        public static void main(String[] args) {
            Thread t1 = new Thread(instance1);
            Thread t2 = new Thread(instance2);
            t1.start();
            t2.start();
            while (t1.isAlive() || t2.isAlive()) { }
            System.out.println("finished");
        }
        @Override
        public void run() {
            synchronized (SynchronizedClassClass5.class) {
                System.out.println("我是类锁的第二种形式：synchronized(*.class)，我叫" + Thread.currentThread().getName());
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "运行结束");
            }
        }
    }

--------------------

# 3 面试考点 #

> 1. 两个线程同时访问一个对象的同步方法

> 2. 两个线程访问的是两个对象的同步方法【**不行**】

public class SynchronizedObjectCodeBlock implements Runnable {
        static SynchronizedObjectCodeBlock instance1 = new SynchronizedObjectCodeBlock();
        static SynchronizedObjectCodeBlock instance2 = new SynchronizedObjectCodeBlock();
        public static void main(String[] args) {
            Thread t1 = new Thread(instance1);
            Thread t2 = new Thread(instance2);
            t1.start();
            t2.start();
            while (t1.isAlive() || t2.isAlive()) { }
            System.out.println("finished");
        }
        @Override
        public void run() {
            synchronized (this) {
                System.out.println("我是对象锁的代码快形式，我叫" + Thread.currentThread().getName());
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "运行结束");
            }
        }
    }

> 3. 两个线程访问的是synchronized的静态方法

public class SynchronizedClassStatic implements Runnable{
        static SynchronizedClassStatic instance1 = new SynchronizedClassStatic();
        static SynchronizedClassStatic instance2 = new SynchronizedClassStatic();
        public static void main(String[] args) {
            Thread t1 = new Thread(instance1);
            Thread t2 = new Thread(instance2);
            t1.start();
            t2.start();
            while (t1.isAlive() || t2.isAlive()) {
    
            }
            System.out.println("finished");
        }
        @Override
        public void run() {
            method();
        }
        public static synchronized void method(){
            System.out.println("我是类锁的第一种形式：static形式，我叫"+Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "运行结束");
        }
    }

> 4. 同时访问同步方法与非同步方法【**不行**】（非同步方法不受到影响）

public class SynchronizedYesAndNo implements Runnable {
        static SynchronizedYesAndNo instance = new SynchronizedYesAndNo();
        public static void main(String[] args) {
            Thread t1 = new Thread(instance);
            Thread t2 = new Thread(instance);
            t1.start();
            t2.start();
            while (t1.isAlive() || t2.isAlive()) { }
            System.out.println("finished");
        }
        @Override
        public void run() {
            if (Thread.currentThread().getName().equals("Thread-0")) {
                method1();
            } else {
                method2();
            }
        }
        public synchronized void method1() {
            System.out.println("我是加锁的方法。我叫" + Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "运行结束");
        }
        public void method2() {
            System.out.println("我是没加锁的方法。我叫" + Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "运行结束");
        }
    }

> 5. 访问同一个对象的不同的普通同步方法

public class SynchronizedDifferentMethod implements Runnable {
        static SynchronizedDifferentMethod instance = new SynchronizedDifferentMethod();
        public static void main(String[] args) {
            Thread t1 = new Thread(instance);
            Thread t2 = new Thread(instance);
            t1.start();
            t2.start();
            while (t1.isAlive() || t2.isAlive()) { }
            System.out.println("finished");
        }
        @Override
        public void run() {
            if (Thread.currentThread().getName().equals("Thread-0")) {
                method1();
            } else {
                method2();
            }
        }
        /**
         * this 作为锁
         */
        public synchronized void method1() {
            System.out.println("我是加锁的方法1。我叫" + Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "运行结束");
        }
        public synchronized void method2() {
            System.out.println("我是加锁的方法2。我叫" + Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "运行结束");
        }
    }

> 6. 同时访问静态synchronized和非静态synchronized方法【**不行**】

public class SynchronizedStaticAndMormal implements Runnable {
        static SynchronizedStaticAndMormal instance = new SynchronizedStaticAndMormal();
        public static void main(String[] args) {
            Thread t1 = new Thread(instance);
            Thread t2 = new Thread(instance);
            t1.start();
            t2.start();
            while (t1.isAlive() || t2.isAlive()) { }
            System.out.println("finished");
        }
        @Override
        public void run() {
            if (Thread.currentThread().getName().equals("Thread-0")) {
                method1();
            } else {
                method2();
            }
        }
        public static synchronized void method1() {
            System.out.println("我是静态加锁的方法1。我叫" + Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "运行结束");
        }
        public synchronized void method2() {
            System.out.println("我是非静态加锁的方法2。我叫" + Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "运行结束");
        }
    }

>  7. 方法抛异常后，会释放锁

public class SynchronizedException implements Runnable {
        static SynchronizedException instance = new SynchronizedException();
        public static void main(String[] args) {
            Thread t1 = new Thread(instance);
            Thread t2 = new Thread(instance);
            t1.start();
            t2.start();
            while (t1.isAlive() || t2.isAlive()) { }
            System.out.println("finished");
        }
        @Override
        public void run() {
            if (Thread.currentThread().getName().equals("Thread-0")) {
                method1();
            } else {
                method2();
            }
        }
        public  synchronized void method1() throws RuntimeException {
            System.out.println("我是方法1。我叫" + Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            throw new RuntimeException();
        }
        public synchronized void method2() {
            System.out.println("我是方法2。我叫" + Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "运行结束");
        }
    }

--------------------

# **4 核心思想** #

>  *  一把锁只能同时被一个线程获取，没有拿到锁的线程必须等待（对应第1、5种情况）；
>  *  每个实例都对应有自己的一把锁，不同实例之间互不影响；例外：锁对象是\*.class以及synchronized修饰的是static方法的时候，所有对象共用同一把类锁（对应第2、3、4、6种情况）；
>  *  无论是方法正常执行完毕或者方法抛出异常，都会释放锁（对应第7种情况）

--------------------

# 5 Synchronized的性质 #

## 5.1 可重入 ##

>  *  什么是可重入：指的是同一线程的外层函数获得锁之后，内层函数可以直接再次获取该锁
>  *  好处：避免死锁、提升封装性
>  *  粒度：线程而非调用（用3种情况来说明和pthread的区别）

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

/**
     * 可重入粒度测试：递归调用本方法
     */
    public class SynchronizedRecursion {
        int a = 0;
        public static void main(String[] args) {
            SynchronizedRecursion recursion = new SynchronizedRecursion();
            recursion.method1();
        }
        private synchronized void method1() {
            System.out.println("这是method1,a = " + a);
            if (a == 0) {
                a++;
                method1();
            }
        }
    }

/**
     * 可重入粒度测试：调用类内另外的方法
     */
    public class SynchronizedOtherMethod {
        public static void main(String[] args) {
            SynchronizedOtherMethod recursion = new SynchronizedOtherMethod();
            recursion.method1();
        }
        private synchronized void method1() {
            System.out.println("我是method1");
            method2();
        }
        private synchronized void method2() {
            System.out.println("我是method2");
        }
    }

/**
     * 可重入粒度测试：调用父类的方法
     */
    public class SynchronizedSuperClass {
        public synchronized void doSomething(){
            System.out.println("我是父类方法");
        }
    }
    class TestClass extends SynchronizedSuperClass{
        @Override
        public synchronized void doSomething() {
            System.out.println("我是子类方法");
            super.doSomething();
        }
        public static void main(String[] args) {
            TestClass s = new TestClass();
            s.doSomething();
        }
    }

## 5.2 不可中断 ##

> 一旦这个锁已经被别人获得了，如果我还想获得，我只能选择等待或者阻塞，直到别的线程**释放**这个锁。如果别人永远不释放锁，那么我只能永远地等下去。

> 相比之下**Lock**类可以拥有中断的能力
> 
>  *  第一点，如果我觉得我等的时间太长了，有权中断现在已经获取到锁的线程的执行
>  *  第二点，如果我觉得我等待的时间太长了不想再等了，也可以退出

--------------------

/**
     * 两种方法是等价的
     */
    public class SynchronizedToLock {
        Lock lock = new  ReentrantLock();
        public synchronized void method1(){
            System.out.println("我是synchronized形式的锁");
        }
        public void method2(){
            lock.lock();
            try{
                System.out.println("我是Lock形式的锁");
            }finally {
                lock.unlock();
            }
        }
        public static void main(String[] args) {
            SynchronizedToLock s = new SynchronizedToLock();
            s.method1();
            s.method2();
        }
    }

--------------------

public class Decompilation {
        private Object object = new Object();
        public void insert(){
            synchronized (object){
    
            }
        }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70][]

[https_www.imooc.com_learn_1086]: https://www.imooc.com/learn/1086
[http_naotu.baidu.com_file_f887c699482a945a02d774582e52e782_token_fce1efb54ad492d4]: http://naotu.baidu.com/file/f887c699482a945a02d774582e52e782?token=fce1efb54ad492d4
[https_zhuanlan.zhihu.com_p_86607654]: https://zhuanlan.zhihu.com/p/86607654
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/2020010722162326.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70