Android多线程：这是一份全面&详细的Synchronized学习指南

今天药忘吃喽~ 2022-05-08 07:24 454阅读 0赞

![fedcf827170b012c679b233fbf30c8bb.png][]

# 前言 #

*  在`Java`中，有一个常被忽略 但 非常重要的关键字`Synchronized`
 *  今天，我将详细讲解 `Java`关键字`Synchronized`的所有知识，希望你们会喜欢

> **Carson带你学多线程系列**  
> 基础汇总  
> [Android多线程：基础知识汇总][Android]  
> 基础使用  
> [Android多线程：继承Thread类使用(含实例教程)][Android_Thread]  
> [Android多线程：实现Runnable接口使用(含实例教程)][Android_Thread]  
> 复合使用  
> [Android多线程：AsyncTask使用教程(含实例讲解)][Android_AsyncTask]  
> [Android多线程：AsyncTask的原理及源码分析][Android_AsyncTask 1]  
> [Android多线程：HandlerThread使用教程(含实例讲解)][Android_HandlerThread]  
> [Android多线程：HandlerThread原理及源码分析][Android_HandlerThread 1]  
> [Android多线程：IntentService使用教程(含实例讲解)][Android_IntentService]  
> [Android多线程：IntentService的原理及源码分析][Android_IntentService 1]  
> [Android多线程：线程池ThreadPool全方位教学][Android_ThreadPool]  
> 相关使用  
> [Android异步通信：这是一份全面&详细的Handler机制学习攻略][Android_Handler]  
> [Android多线程：手把手教你全面学习神秘的Synchronized关键字][Android_Synchronized]  
> [Android多线程：带你了解神秘的线程变量 ThreadLocal][Android_ ThreadLocal]

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

# 目录 #

![示意图][b6924bd0d034de50727d3be5db3c3e1a.png]

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

# 1. 定义 #

`Java`中的1个关键字

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

# 2. 作用 #

保证同一时刻最多只有1个线程执行 被`Synchronized`修饰的方法 / 代码

> 其他线程 必须等待当前线程执行完该方法 / 代码块后才能执行该方法 / 代码块

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

# 3. 应用场景 #

**保证线程安全，解决多线程中的并发同步问题（实现的是阻塞型并发）**，具体场景如下：

1.  修饰 实例方法 / 代码块时，（同步）保护的是同一个对象方法的调用 & 当前实例对象
2.  修饰 静态方法 / 代码块时，（同步）保护的是 静态方法的调用 & class 类对象

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

# 4. 原理 #

1.  依赖 `JVM` 实现同步
2.  底层通过一个监视器对象`（monitor）`完成， `wait（）`、`notify（）` 等方法也依赖于 monitor 对象

> 监视器锁（monitor）的本质 依赖于 底层操作系统的互斥锁（Mutex Lock）实现

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

# 5. 具体使用 #

`Synchronized` 用于 修饰 代码块、类的实例方法 & 静态方法

### 5.1 使用规则 ###

![示意图][05330773ba468a588fa4e8f42dd7a7e9.png]

### 5.2 锁的类型 & 等级 ###

*  由于`Synchronized` 会修饰 代码块、类的实例方法 & 静态方法，故分为不同锁的类型
 *  具体如下

![示意图][713d266272dd5fba98702699e752e7c5.png]

*  之间的区别

![示意图][c6707ccca6925053b7d4199e9cb6e628.png]

### 5.3 使用方式 ###

/**
     * 对象锁
     */
        public class Test{ 
        // 对象锁：形式1(方法锁) 
        public synchronized void Method1(){ 
            System.out.println("我是对象锁也是方法锁"); 
            try{ 
                Thread.sleep(500); 
            } catch (InterruptedException e){ 
                e.printStackTrace(); 
            } 
     
        } 
     
        // 对象锁：形式2（代码块形式） 
        public void Method2(){ 
            synchronized (this){ 
                System.out.println("我是对象锁"); 
                try{ 
                    Thread.sleep(500); 
                } catch (InterruptedException e){ 
                    e.printStackTrace(); 
                } 
            } 
     
        } 
     ｝
    
    /**
     * 方法锁（即对象锁中的形式1）
     */
        public synchronized void Method1(){ 
            System.out.println("我是对象锁也是方法锁"); 
            try{ 
                Thread.sleep(500); 
            } catch (InterruptedException e){ 
                e.printStackTrace(); 
            } 
     
        } 
    
    /**
     * 类锁
     */
    public class Test{ 
    　　 // 类锁：形式1 ：锁静态方法
        public static synchronized void Method1(){ 
            System.out.println("我是类锁一号"); 
            try{ 
                Thread.sleep(500); 
            } catch (InterruptedException e){ 
                e.printStackTrace(); 
            } 
     
        } 
     
        // 类锁：形式2 ：锁静态代码块
        public void Method2(){ 
            synchronized (Test.class){ 
                System.out.println("我是类锁二号"); 
                try{ 
                    Thread.sleep(500); 
                } catch (InterruptedException e){ 
                    e.printStackTrace(); 
                } 
     
            } 
     
        } 
    ｝

### 5.4 特别注意 ###

`Synchronized`修饰方法时存在缺陷：若修饰1个大的方法，将会大大影响效率

*  示例  
    若使用`Synchronized`关键字修饰 线程类的`run()`，由于`run()`在线程的整个生命期内一直在运行，因此将导致它对本类任何`Synchronized`方法的调用都永远不会成功
 *  解决方案  
    使用 `Synchronized`关键字声明代码块

> 该解决方案灵活性高：可针对任意代码块 & 任意指定上锁的对象

代码如下
      synchronized(syncObject) { 
        // 访问或修改被锁保护的共享状态 
        // 上述方法 必须 获得对象 syncObject（类实例或类）的锁
    }

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

# 6. 特点 #

![示意图][a05fa6bf660e8677211be883f947472d.png]

注：原子性、可见性、有序性的定义

![示意图][2233b1a1eaa2fcdbbf68061726970854.png]

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

# 7. 其他控制并发 / 线程同步方式 #

### 7.1 Lock、ReentrantLock ###

*  简介

![示意图][06262ae3c9ea1f5c11d1d1452c7f32d5.png]

*  区别

![示意图][29980bef734d7a169e5f490d58a0a38c.png]

### 7.2 CAS ###

##### 7.2.1 定义 #####

`Compare And Swap`，即 比较 并 交换，是一种解决并发操作的乐观锁

> `synchronized`锁住的代码块：同一时刻只能由一个线程访问，属于悲观锁

##### 7.2.2 原理 #####

// CAS的操作参数
    内存位置（A）
    预期原值（B）
    预期新值（C）
    
    // 使用CAS解决并发的原理：
    // 1. 首先比较A、B，若相等，则更新A中的值为C、返回True；若不相等，则返回false；
    // 2. 通过死循环，以不断尝试尝试更新的方式实现并发
    
    // 伪代码如下
    public boolean compareAndSwap(long memoryA, int oldB, int newC){
        if(memoryA.get() == oldB){
            memoryA.set(newC);
            return true;
        }
        return false;
    }

##### 7.2.3 优点 #####

资源耗费少：相对于`synchronized`，省去了挂起线程、恢复线程的开销

> 但，若迟迟得不到更新，死循环对`CPU`资源也是一种浪费

##### 7.2.4 具体实现方式 #####

*  使用CAS有个“先检查后执行”的操作
 *  而这种操作在Java中是典型的不安全的操作，所以 `CAS`在实际中是**由`C++`通过调用CPU指令实现的**
 *  具体过程

// 1. CAS在Java中的体现为Unsafe类
    // 2. Unsafe类会通过C++直接获取到属性的内存地址
    // 3. 接下来CAS由C++的Atomic::cmpxchg系列方法实现

##### 7.2.5 典型应用：`AtomicInteger` #####

对 i++ 与 i–，通过`compareAndSet` & 一个死循环实现

> 而`compareAndSet`函数内部 = 通过`jni`操作`CAS`指令。直到CAS操作成功跳出循环

private volatile int value; 
        /** 
         * Gets the current value. 
         * 
         * @return the current value 
         */ 
        public final int get() { 
            return value; 
        } 
        /** 
         * Atomically increments by one the current value. 
         * 
         * @return the previous value 
         */ 
        public final int getAndIncrement() { 
            for (;;) { 
                int current = get(); 
                int next = current + 1; 
                if (compareAndSet(current, next)) 
                    return current; 
            } 
        } 
     
        /** 
         * Atomically decrements by one the current value. 
         * 
         * @return the previous value 
         */ 
        public final int getAndDecrement() { 
            for (;;) { 
                int current = get(); 
                int next = current - 1; 
                if (compareAndSet(current, next)) 
                    return current; 
            } 
        }

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

# 8. 总结 #

*  本文主要对`Java`中常被忽略 但 非常重要的关键字`Synchronized`进行讲解
 *  **Carson带你学多线程系列**

> 基础汇总  
> [Android多线程：多线程基础知识汇总][Android]  
> 基础使用  
> [Android多线程：继承Thread类使用(含实例教程)][Android_Thread]  
> [Android多线程：实现Runnable接口使用(含实例教程)][Android_Thread]  
> 复合使用  
> [Android多线程：AsyncTask使用教程(含实例讲解)][Android_AsyncTask]  
> [Android多线程：AsyncTask的原理及源码分析][Android_AsyncTask 1]  
> [Android多线程：HandlerThread使用教程(含实例讲解)][Android_HandlerThread]  
> [Android多线程：HandlerThread的原理及源码分析][Android_HandlerThread 1]  
> [Android多线程：IntentService使用教程(含实例讲解)][Android_IntentService]  
> [Android多线程：IntentService的原理及源码分析][Android_IntentService 1]  
> [Android多线程：线程池ThreadPool全方位教学][Android_ThreadPool]  
> 相关使用  
> [Android异步通信：这是一份全面&详细的Handler机制学习攻略][Android_Handler]  
> [Android多线程：手把手教你全面学习神秘的Synchronized关键字][Android_Synchronized]  
> [Android多线程：带你了解神秘的线程变量 ThreadLocal][Android_ ThreadLocal]

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

# 欢迎关注Carson\_Ho的[CSDN博客][CSDN] 与 公众号！ #

博客链接：https://carsonho.blog.csdn.net/  
![06b2ed0fbb8979f0aba34c14ede04b59.png][]

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

# 请帮顶 / 评论点赞！因为你的鼓励是我写作的最大动力！ #

[fedcf827170b012c679b233fbf30c8bb.png]: /images/20220508/d3f1344f1a46426b9ff726c8a9eba685.png
[Android]: https://carsonho.blog.csdn.net/article/details/90166487
[Android_Thread]: https://carsonho.blog.csdn.net/article/details/80506008
[Android_AsyncTask]: https://carsonho.blog.csdn.net/article/details/79314325
[Android_AsyncTask 1]: https://carsonho.blog.csdn.net/article/details/79314326
[Android_HandlerThread]: https://carsonho.blog.csdn.net/article/details/79285760
[Android_HandlerThread 1]: https://carsonho.blog.csdn.net/article/details/52693418
[Android_IntentService]: https://carsonho.blog.csdn.net/article/details/90437126
[Android_IntentService 1]: https://carsonho.blog.csdn.net/article/details/53407806
[Android_ThreadPool]: https://carsonho.blog.csdn.net/article/details/80060201
[Android_Handler]: https://carsonho.blog.csdn.net/article/details/51290360
[Android_Synchronized]: https://blog.csdn.net/carson_ho/article/details/82992269?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522163210663616780271522004%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fblog.%2522%257D&request_id=163210663616780271522004&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~blog~first_rank_v2~rank_v29-1-82992269.pc_v2_rank_blog_default&utm_term=Synchronized&spm=1018.2226.3001.4450
[Android_ ThreadLocal]: https://blog.csdn.net/carson_ho/article/details/82344011?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522163210666516780261991412%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fblog.%2522%257D&request_id=163210666516780261991412&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~blog~first_rank_v2~rank_v29-1-82344011.pc_v2_rank_blog_default&utm_term=%E7%BA%BF%E7%A8%8B%E5%8F%98%E9%87%8F&spm=1018.2226.3001.4450
[b6924bd0d034de50727d3be5db3c3e1a.png]: /images/20220508/a66c1abcec1846ffa73039298996d1e3.png
[05330773ba468a588fa4e8f42dd7a7e9.png]: /images/20220508/cea7ac8a28894fbdb46e6ab6f192435f.png
[713d266272dd5fba98702699e752e7c5.png]: /images/20220508/f87346e495354aadae5fa00db6bff3cf.png
[c6707ccca6925053b7d4199e9cb6e628.png]: /images/20220508/309fb8c4fea54995a8b57adb3a4eebf2.png
[a05fa6bf660e8677211be883f947472d.png]: /images/20220508/abed4218ef4247e7ae838cfc39b3182b.png
[2233b1a1eaa2fcdbbf68061726970854.png]: /images/20220508/02eee5daea7944118cd5696ae3a2de37.png
[06262ae3c9ea1f5c11d1d1452c7f32d5.png]: /images/20220508/e0a769e41ac246c686fdd69e860ce383.png
[29980bef734d7a169e5f490d58a0a38c.png]: /images/20220508/b53acc3743f646e6998fcfb2f46197ff.png
[CSDN]: https://carsonho.blog.csdn.net/
[06b2ed0fbb8979f0aba34c14ede04b59.png]: /images/20220508/09b69af06a5645199025a78328e48534.png