Java 从多线程到并发编程（六）—— 并发同步锁阻塞 synchronized四种应用形式

约定不等于承诺〃 2022-10-30 10:22 100阅读 0赞

### 文章目录 ###

*   *  前言 ´･ᴗ･\`
     *  并发 不安全案例
     *  线程同步 互斥体 阻塞 锁 感性理解
     *  Synchronized——同步的简单实现
     *  synchronized的四种修饰形式解读
     *  同步代码块的使用
     *  同步“静态”对象
     *  类锁
     *  类锁demo答案
     *  总结 ´◡\`

## 前言 ´･ᴗ･\` ##

*  继上一次我们主要学习了线程礼让yield 线程强制执行join 线程自我阻塞sleep等相关的知识
 *  本节将会帮助你了解…
    
     *  并发 同步 锁 阻塞 互斥 临界资源 synchronized概念浅析
     *  synchronized **四种** 实现形式的理解以及demo

毕竟线程不讲 同步与线程安全 等于没怎么讲2333

这一节可以说是解决生产者消费者问题的基础之一，好好学：）

## 并发 不安全案例 ##

在前面我们有个例子 用Runnable 实现 三个robot抢票这个案例 如代码：

package com.base.threadlearning.threadVSrunnable;
    
    
    
    public class RunnableTicket implements Runnable{
        
        private static final int TICKETS=10;
        private int tickets;
        private boolean flag;
    
        RunnableTicket(){
        
            tickets=TICKETS;
            flag=true;
        }
        public void setFlag(Boolean flag){
        
            this.flag = flag;
        }
    
        @Override
        public void run(){
        
            while(flag){
        
                if(tickets<=0) break;
    
                try {
        
                    Thread.sleep(200);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+" get the "+tickets--+" tickets");
            }
        }
    
        public static void main(String[] args) throws InterruptedException {
        
            RunnableTicket ticket_station = new RunnableTicket();
            String[] Robot_array = {
        "Robot A","Robot B","Robot C"};
    
            for(String i : Robot_array){
        
                new Thread(ticket_station,i).start();
            }
            Thread.sleep(4000);
            TicketController ticketController = new TicketController(ticket_station);
            new Thread(ticketController).start();
        }
    }

这里多个线程访问同一个对象资源 被称为**并发**

那么这里我们的逻辑 处理并发 导致最后票竟然会出现-1这种情况，如图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzE3ODgyOA_size_16_color_FFFFFF_t_70]

但流程控制中我们有  
![在这里插入图片描述][20210220111559370.png]  
当小于等于0的时候停止挖票的逻辑 所以这个处理并发的逻辑问题出在哪？  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzE3ODgyOA_size_16_color_FFFFFF_t_70 1]  
这里 线程执行相互独立 假设有一个线程A跑到1这个地方 这时tickets 给我们公开的信息是还剩一张 但实际上线程A应该算是拿到票了 只不过等待一下网络请求的200ms

就好像你买东西 都把东西放到收银台了（预定了） 就差付钱了

这时线程B看到 诶 还有1张 我还可以抢 于是他也开抢 他也预定了这张票

这就相当于本来只有一张票 却好像有两张票都能被预定一样

如果还有线程CDEFG 那要多少有多少 —— **只要第一个线程A没有更新tickets值**

或许有个思路就是 我预约完**立即更新**tickets值 但实际上 因为tickets值在服务器 你客户端请求服务器当然需要时间 所以不可能实现

那么就只剩下一个更加直接的方法 **上锁** 也被称为**同步**

说白了 好像上厕所 咱们一个一个来 上厕所锁门 后面的人就得等着 不能蜂拥而上 只能串行执行

## 线程同步 互斥体 阻塞 锁 感性理解 ##

既然如此 我们只能想上厕所一样 排好队 这可以被称为 **在对象的等待池中 形成队列**

还记得第一篇文章讲进程的时候 我们说单核CPU只能同时为**一个**进程提供计算服务  
而其他进程只能干瞪眼 乖乖排队就绪 直到自己的优先级达到了才行 这里 这个特点上也非常类似

如果你想让一个方法 实现像厕所一样的效果 也就是调用此方法必须**同步执行** 调用线程只能一个一个操作

其实我们这种同步方式也有个名字 称为**互斥体**，它实现了“互相排斥”（mutual exclusion）同步的简单形式（所以名为互斥体(mutex)），其定义就是 互斥体禁止**多个线程同时进入受保护的代码“临界区”**（critical section），线程与线程之间**互斥**

我们称 占用当前对象的线程 也就是上到厕所的线程 **拿到了锁** 即你终于可以上厕所的时候 上了一把锁一样  
上完厕所后你就**释放（release）了锁**（解开了锁 否则别人上不了）

另一个角度来说 上不了厕所 在等的那批人 也就是被**阻塞了** 被门挡住了

这个时候就非常低效 因为等待的人只能无所事事

当然如果他们顺便玩玩手机刷刷抖音 那就说明他们是**多线程**操作——上厕所的线程阻塞了 不妨碍其他刷抖音的线程跑起来啊

https://www.cnblogs.com/weibanggang/p/9470718.html

## Synchronized——同步的简单实现 ##

我们可以使用**synchronized** 这个关键字 实现互斥 线程同步的效果 这个关键字可以用于**方法、代码块、类、静态方法**（用大括号括起来即可）

但是无论如何 其修饰的 或者说作用的根本 是**对象**

比方说 如果两个线程**各自作用一个对象** 那么你再synchronized这两个对象 这两个线程依然可以交替 “多线程”的“并行”执行

因为每个对象（比如 类似我们之前的案例 两个卖票站）只遇到一个线程在抢票 线程与线程之间并不能形成互斥

但是如果你理解为作用的是那个方法 你会以为同步的是方法那个函数对象 那你就以为这里线程会同步执行

事实上我们确实只需要保证所谓线程是互斥的 访问 **临界资源** 即一个一个来上厕所 所以锁的是临界资源 锁的是坑位 不是锁方法 或者代码块本身

我们直接上例子你就明白了：  
这里 三个挖票机器人vs一个售票处

package com.base.threadlearning.threadState;
    // 队列+锁机制 保证线程安全 否则同时操作同一个对象并发就会出问题
    // 线程持有锁 会导致其他线程挂起 time wait
    // 优先级高的线程等待一个优先级低的线程释放锁 会导致优先级倒置！
    
    public class ThreadSync {
        
        public static void main(String[] args) {
        
            // 同一个ticket station
            ticket station = new ticket();
    
            new Thread(station,"a ").start();
            new Thread(station,"b ").start();
            new Thread(station,"c ").start();
        }
    
    }
    
    
    class ticket implements Runnable{
        
        private int ticket = 10;
        boolean flag = true;
        @Override
        public void run() {
        
            while (flag){
        
                try {
        
                    buy();
                    Thread.sleep(100);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
            }
    
        }
        
        private synchronized void buy() throws InterruptedException {
        
            if(ticket<=0) {
        
                flag = false;
                return;
            }
            Thread.sleep(100);
            System.out.println(Thread.currentThread().getName()+"get "+ticket--);
        }
    }

这里执行确实是同步执行的 三个robot互斥 结果如下：

a get 10
    c get 9
    b get 8
    c get 7
    a get 6
    c get 5
    b get 4
    c get 3
    a get 2
    c get 1
    
    Process finished with exit code 0

那三个挖票机器人VS三个售票处 各自在各自的售票处挖 1v1

public class ThreadSync {
        
        public static void main(String[] args) {
        
            // 同一个ticket station
    //        ticket station = new ticket();
    
            new Thread(new ticket(),"a ").start();
            new Thread(new ticket(),"b ").start();
            new Thread(new ticket(),"c ").start();
        }
    }
    // 其他部分代码相同 就不写了

结果：

b get 10
    c get 10
    a get 10
    a get 9
    c get 9
    b get 9
    c get 8
    a get 8
    b get 8
    a get 7
    b get 7
    c get 7
    c get 6
    b get 6
    a get 6
    a get 5
    c get 5
    b get 5
    c get 4
    a get 4
    b get 4
    a get 3
    c get 3
    b get 3
    a get 2
    c get 2
    b get 2
    a get 1
    c get 1
    b get 1

我们可以看到 三个线程并没有互斥 彼此并不干扰 而且如果你三个三个看 （每个售票处的1号票 2号票······）你可以发现robot顺序不同 bca - > acb -> bac 这也表现了线程并没有同步执行

那么我们这里修饰了buy方法 如果换成run 会怎么样？

## synchronized的四种修饰形式解读 ##

这里我给你个表：  
**作用对象**就是那些本应该互斥的线程 线程（挖票机）调用售票处的方法（售票终端）进行挖票 或者说正在等厕所坑位空闲的我。。。

**上锁对象**就是 所谓临界资源 需要保护的资源 也就是厕所坑位

<table> 
 <thead> 
  <tr> 
   <th>修饰内容</th> 
   <th>上锁对象</th> 
   <th>作用对象（互斥体）</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>代码块（同步代码块）</td> 
   <td>代码</td> 
   <td>调用这个代码块的对象</td> 
  </tr> 
  <tr> 
   <td>方法（同步方法）</td> 
   <td>方法</td> 
   <td>调用这个方法的对象</td> 
  </tr> 
  <tr> 
   <td>静态方法</td> 
   <td>静态方法</td> 
   <td>所属类的所有<strong>对象实例</strong>（静态方法属于类信息）</td> 
  </tr> 
  <tr> 
   <td>类</td> 
   <td>括号范围</td> 
   <td>类的所有<strong>对象实例</strong></td> 
  </tr> 
 </tbody> 
</table>

上面这张表就是**四种修饰形式**

那你说改成run有区别吗？答案是**没有**

因为作用（使同步）的对象还是那三个挖票机 而临界资源也没什么本质变化 因为是三个售票处 三个售票处各自tickets-- 以及网络请求300ms延时 所以出来的效果**一样的** 如下：

a get 10
    b get 10
    c get 10
    b get 9
    a get 9
    c get 9
    a get 8
    b get 8
    c get 8
    c get 7
    a get 7
    b get 7
    b get 6
    c get 6
    a get 6
    b get 5
    c get 5
    a get 5
    c get 4
    b get 4
    a get 4
    a get 3
    b get 3
    c get 3
    b get 2
    a get 2
    c get 2
    c get 1
    a get 1
    b get 1

还是各自为政 各挖各的售票处

那如果对**同一个售票处** 我修饰run会怎么样？也即是真正的并发情况下

这时代码如下：

package com.base.threadlearning.threadState;
    
    public class ThreadSync {
        
        public static void main(String[] args) {
        
            // 同一个ticket station
            ticket station = new ticket();
    
            new Thread(station,"a ").start();
            new Thread(station,"b ").start();
            new Thread(station,"c ").start();
        }
    
    }
    class ticket implements Runnable{
        
        private int ticket = 10;
        boolean flag = true;
        @Override
        public synchronized void run() {
        
            while (flag){
        
                try {
        
                    buy();
                    Thread.sleep(100);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
            }
    
        }
    
        private void buy() throws InterruptedException {
        
            if(ticket<=0) {
        
                flag = false;
                return;
            }
            Thread.sleep(100);
            System.out.println(Thread.currentThread().getName()+"get "+ticket--);
        }
    }

这时的结果也是绝了：

a get 10
    a get 9
    a get 8
    a get 7
    a get 6
    a get 5
    a get 4
    a get 3
    a get 2
    a get 1

感觉a承包了这个station售票处。。为什么？

我们这里的临界资源 上锁的东西变为**整个售票处** 意味着只要a挖票没挖完 **永远不释放售票处的锁** 那么b c都别想进售票处操作

而前面我们上锁的只是买票的函数接口buy而已 也就是你a**买完一张 就把锁释放了**  
接下来我们**a b c都可以买** 全看调度器怎么抉择而已

## 同步代码块的使用 ##

这个和同步方法差不多·一般是做**等效** 比如 我们利用同步代码块等效一下 **同步run方法** 就可以这么写：

class ticket implements Runnable{
        
        private int ticket = 10;
        boolean flag = true;
        @Override
        public synchronized void run() {
        
            synchronized (this){
        
                while (flag){
        
                    try {
        
                        buy();
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                }
            }
    
    
        }

那么为啥还要用同步代码块呢？我的理解是 很多情况下函数并非最小功能的执行单位 或者说需求同步的最小单位 那么函数粒度不够 就用同步代码块即可

比如 函数可能涉及很多局部变量 但是真正需要同步上锁的只有计算部分 那干脆保护更核心的部分好了：）

## 同步“静态”对象 ##

所谓静态的对象 就是**类和静态的方法**

为什么说是静态的 因为类的属性以及其静态方法是**写死**在class字节码文件里面的 这些配置不变

因此就会有很有意思的情况  
比如对于第三种方式 当你synchronized一个静态方法 然后线程使用它的时候 这个静态方法本来作为一个类似工具 用来即时计算的东西 但实际上却进行了同步 **里面的数据**是被保护的 我们看个例子

package com.base.threadlearning.threadState;
    
    public class ThreadSync {
        
        public static void main(String[] args) {
        
    
            new Thread(new ticket(),"a ").start();
            new Thread(new ticket(),"b ").start();
            new Thread(new ticket(),"c ").start();
        }
    
    }
    class MathTool{
        
        private static int count=30;
    
        public synchronized static void getNum(String threadName) throws InterruptedException {
        
            System.out.println(threadName+" getNum "+count--);
        }
    
    }
    
    class ticket implements Runnable{
        
        private int ticket = 10;
        boolean flag = true;
        @Override
        public synchronized void run() {
        
            synchronized (this){
        
                while (flag){
        
                    try {
        
                        buy();
                        // request time
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                }
            }
        }
    
        private void buy() throws InterruptedException {
        
            if(ticket<=0) {
        
                flag = false;
                return;
            }
            Thread.sleep(100);
            String threadName = Thread.currentThread().getName();
            System.out.println(threadName+" get "+ticket--);
            MathTool.getNum(threadName);
        }
    }

MathTool这个类作为工具类 有静态方法供人调用 结果就可以实现三个售票处总共票被挖取的倒计效果（实时显示三个站还剩多少票）

a  get 10
    b  get 10
    c  get 10
    a  getNum 30
    c  getNum 29
    b  getNum 28
    c  get 9
    a  get 9
    b  get 9
    c  getNum 27
    b  getNum 26
    a  getNum 25
    b  get 8
    a  get 8
    c  get 8
    b  getNum 24
    c  getNum 23
    a  getNum 22
    b  get 7
    c  get 7
    a  get 7
    b  getNum 21
    a  getNum 20
    c  getNum 19
    b  get 6
    a  get 6
    c  get 6
    b  getNum 18
    c  getNum 17
    a  getNum 16
    b  get 5
    a  get 5
    c  get 5
    b  getNum 15
    c  getNum 14
    a  getNum 13
    a  get 4
    c  get 4
    b  get 4
    a  getNum 12
    b  getNum 11
    c  getNum 10
    c  get 3
    a  get 3
    b  get 3
    c  getNum 9
    b  getNum 8
    a  getNum 7
    b  get 2
    c  get 2
    a  get 2
    b  getNum 6
    a  getNum 5
    c  getNum 4
    b  get 1
    b  getNum 3
    c  get 1
    a  get 1
    c  getNum 2
    a  getNum 1

如果不同步这个静态方法 那么count这个变量便不再受到保护 （count只有一个 因为是静态的）  
![在这里插入图片描述][20210220172721815.png]  
同步静态的方法 我们只能保护方法里面的变量 但是如果同步类 那效果是 —— **保护所有类实例** 换言之 只要是使用了这个类字节码的类实例 ClassName.class 都用的**同一把锁**~

## 类锁 ##

前面三种基本上都是针对一个对象 比如一个方法 一个代码块 又称为对象的**内置锁** 是**单个**对象上锁

但是这里是**类锁** 所有类实例共用一把锁 相当于一群实例**共有的锁**

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

**这里我出道题：** 如何让三个售票处 所有的票 都是一张一张卖的 比如一个售票处10张票 那么就会30张票一张一张出 这不是三个售票处 10张票售卖还能并行三线程

限定条件：

*  主线程长这样的（就是之前 三个售票处那种demo）

public class ThreadSync {
        
        public static void main(String[] args) {
        
    
            new Thread(new ticket(),"a ").start();
            new Thread(new ticket(),"b ").start();
            new Thread(new ticket(),"c ").start();
        }
    
    }

*  在之前三个售票处的demo基础上 **只更改两行代码**

## 类锁demo答案 ##

我给上代码 你们看看功能实现了没：

package com.base.threadlearning.threadState;
    
    public class ThreadSync {
        
        public static void main(String[] args) {
        
    
            new Thread(new ticket(),"a ").start();
            new Thread(new ticket(),"b ").start();
            new Thread(new ticket(),"c ").start();
        }
    
    }
    
    
    class ticket implements Runnable{
        
        private int ticket = 10;
        boolean flag = true;
        @Override
        public void run() {
        
            synchronized (ticket.class) {
        
                while (flag) {
        
                    try {
        
                        buy();
                        // request time
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                }
            }
        }
    
        private void buy() throws InterruptedException {
        
    
                if (ticket <= 0) {
        
                    flag = false;
                    return;
                }
                Thread.sleep(100);
                String threadName = Thread.currentThread().getName();
                System.out.println(threadName + " get " + ticket--);
            }
    
    }

a  get 10
    a  get 9
    a  get 8
    a  get 7
    a  get 6
    a  get 5
    a  get 4
    a  get 3
    a  get 2
    a  get 1
    c  get 10
    c  get 9
    c  get 8
    c  get 7
    c  get 6
    c  get 5
    c  get 4
    c  get 3
    c  get 2
    c  get 1
    b  get 10
    b  get 9
    b  get 8
    b  get 7
    b  get 6
    b  get 5
    b  get 4
    b  get 3
    b  get 2
    b  get 1

怎么实现的呢？原因全在这两行：

synchronized (ticket.class) {
        
    
    }

发现了没有 无论多少售票处 没有意义 因为售票处实例都被同一把锁锁住了  
因此 就好像有个农贸市场 售票市场 里面三个售票处 你人只能一次进去一个 当然你选哪家售票处 那随便（这个demo就默认选一家了）

又因为 我们控制的范围是run 所以只有robot a用完了整个售票市场 他挖完自己所有所需的票 b c才能进去

## 总结 ´◡\` ##

这四种实现形式都有相应的应用 活学活用很难：） 不过再难 看着看着就会了 加油奥利给

有几个冷知识需要注意

*  synchronized关键字**不能继承** 你父类的方法synchronized与我子类的super无瓜！
 *  在定义接口方法时不能使用synchronized关键字
 *  构造方法不能使用synchronized关键字，但可以使用synchronized代码块包起来

然后就是这张表了：

<table> 
 <thead> 
  <tr> 
   <th>修饰内容</th> 
   <th>上锁对象</th> 
   <th>作用对象（互斥体）</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>代码块（同步代码块）</td> 
   <td>代码</td> 
   <td>调用这个代码块的对象</td> 
  </tr> 
  <tr> 
   <td>方法（同步方法）</td> 
   <td>方法</td> 
   <td>调用这个方法的对象</td> 
  </tr> 
  <tr> 
   <td>静态方法</td> 
   <td>静态方法（主要是里面的变量）</td> 
   <td>所属类的所有<strong>对象实例</strong>（静态方法属于类信息）</td> 
  </tr> 
  <tr> 
   <td>类</td> 
   <td>括号范围</td> 
   <td>类的所有<strong>对象实例</strong></td> 
  </tr> 
 </tbody> 
</table>

下一节 我们会聊到synchronize怎么结合和wait/notify 机制，解决**生产者消费者问题**

Java 从多线程到并发编程（七）—— wait notify 生产者消费者问题

*  本文专栏
    
     *  [Java专栏][Java]
 *  我的其他专栏 希望能够帮到你 ( •̀ ω •́ )✧
    
     *  [MySQL专栏][MySQL]
     *  [手把手带你学后端（服务端）][Link 1]
     *  [python应用][python]
 *  谢谢大佬支持! 萌新有礼了：）

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzE3ODgyOA_size_16_color_FFFFFF_t_70]: /images/20221024/d7b5dbdc6a7440ea95b71b8d73c9e518.png
[20210220111559370.png]: /images/20221024/395d2b07ecfd4323885983a34063d165.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzE3ODgyOA_size_16_color_FFFFFF_t_70 1]: /images/20221024/ff235080dc654922b1558fe91ee8745d.png
[20210220172721815.png]: /images/20221024/dbc21f72ee274b5e9b7b917209b496c9.png
[Java]: https://blog.csdn.net/weixin_43178828/category_10370800.html
[MySQL]: https://blog.csdn.net/weixin_43178828/category_9681934.html
[Link 1]: https://blog.csdn.net/weixin_43178828/category_9705593.html
[python]: https://blog.csdn.net/weixin_43178828/category_9684088.html