zoukankan      html  css  js  c++  java
  • 1:初始锁这个概念

    1:什么是锁?

    在JAVA中是一个非常重要的概念,尤其是在当今的互联网时代,高并发的场景下,更是离不开锁。那么锁到底是什么呢?在计算机科学中,锁(lock)或互斥(mutex)是一种同步机制,用于在有许多执行线程的环境中强制对资源的访问进行限制。锁旨在强制实施互斥排他、并发控制策略。咱们举一个生活的例子来更好的理解锁:大家都去过超市买东西,如果你随身带了包呢,要放到储物柜里。咱们把这个例子再极端一下,假如柜子只有一个,现在同时来了3个人A,B,C,都要往这个柜子里放东西。这个场景就构造了一个多线程,多线程自然离不开锁。如下图所示:

    2:不使用锁,并发情况下会导致的问题

    A,B,C都要往柜子里放东西,可是柜子只能放一件东西,那怎么办呢?这个时候呢就引出了锁的概念,3个人中谁抢到了柜子的锁,就可以使用这个柜子,其他的人就只能等待。比如:C抢到了锁,C可以使用这个柜子。A和B只能等待,等C使用完了,释放锁以后,A和B再争抢锁,谁抢到了,在继续使用柜子

    将上面的场景用代码的方式进行实现

    package com.bfxy.esjob.lock;
    
    /**
     * @Author: qiuj
     * @Description:    柜子
     * @Date: 2020-06-26 15:20
     */
    public class Cabinet {
        //  柜子里存放的数字
        private Integer number;
    
        public Integer getNumber() {
            return number;
        }
    
        public void setNumber(Integer number) {
            this.number = number;
        }
    }
    
    package com.bfxy.esjob.lock;
    
    /**
     * @Author: qiuj
     * @Description:    用户
     * @Date: 2020-06-26 15:20
     */
    public class User {
        //  柜子
        private Cabinet cabinet;
        //  存储的数字
        private Integer myNumber;
    
        public User(Cabinet cabinet, Integer myNumber) {
            this.cabinet = cabinet;
            this.myNumber = myNumber;
        }
    
        public void useCabinet () {
            cabinet.setNumber(myNumber);
        }
    }
    
    package com.bfxy.esjob;
    
    import com.bfxy.esjob.lock.Cabinet;
    import com.bfxy.esjob.lock.User;
    
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    /**
     * @Author: qiuj
     * @Description:
     * @Date: 2020-06-26 15:23
     */
    public class Tests {
        public static void main(String[] args) {
            //  只有一个柜子  有3个用户
            Cabinet cabinet = new Cabinet();
            //  创建线程池
            ExecutorService executorService = Executors.newFixedThreadPool(3);
            for (int i = 0; i < 3; i++) {
                final Integer number = i;
                executorService.execute(() -> {
                    User user = new User(cabinet,number);
                    user.useCabinet();
                    System.out.println("客户的编号:" + number + "柜子里的数字:" + cabinet.getNumber());
                });
            }
            executorService.shutdown();
        }
    }
    

    我们仔细看一下main 函数执行的过程

    • 首先创建一个柜子的实例,由于场景只有一个柜子,所以我们只创建一个柜子实例
    • 然后新建了一个线程池,线程池中有3个线程,每个线程执行一个用户的操作
    • 再来看看每个线程具体的执行过程,新建用户实例,传入的是用户使用的柜子,我们这里只有一个柜子,所以传入这个柜子的实例,然后传入这个用户要存储的数字,分别是 0、1、2 ,也分别对应着用户A、用户B、和用户C
    • 再调用使用柜子的操作,也就是向柜子中放入要存储的数字,然后立刻从柜子中取出数字,并打印出来

    执行main 方法的结果

    客户的编号:1柜子里的数字:2
    客户的编号:0柜子里的数字:2
    客户的编号:2柜子里的数字:2

    再次执行一次,

    客户的编号:0柜子里的数字:1
    客户的编号:2柜子里的数字:1
    客户的编号:1柜子里的数字:1

    从结果中我们发现 3个用户柜子中存储的数字都是一样的,这是为什么?

    问题就出在user.useCabinet() 方法上,三个线程并发的往柜子存放上自己的数字。
    但是 number 值只占有一块内存,换句话说就是只能存放一个值。那么最早往柜子赋值的用户的就会被新的覆盖
    最终显示的就是最后一个线程赋的值

    3:使用锁,解决并发情况下造成变量值前后不一致的问题

    那么在程序中如何加锁呢?这就要使用JAVA中的一个关键字 --synchronized 。
    synchronized 分为 synchronized方法  和 synchronized同步代码块

    下面我们看一下两者的具体用法:

    • synchronized 方法,顾名思义,是把 synchronized 关键字写在方法上,它表示这个方法是加了锁的,当多个线程同时调用这个方法时,只有获得锁的线程才允许执行这个方法 。
        public synchronized String getTicket(){
            return "xxx";
        }

    我们可以看到 getTicket() 方法加了锁,当多个线程并发执行的时候,只有获得锁的线程才可以执行,其他线程只能等待

    • 我们再来看看 synchronized 块,synchronized 块的语法是:
    synchronized (对象锁) {
        ......
    }

    synchronized 代码块内的代码将上锁,而锁是  synchronized(对象锁)   也就是 括号内的对象(object)  持有括号内的对象的线程才允许进行方法体

    再回到我们的示例当中,如何解决number 混乱的问题呢?咱们可以在设置 storeNumber 的方法上加上锁,这样保证同时只有一个线程能调用这个方法。如下所示:

    package com.bfxy.esjob.lock;
    
    /**
     * @Author: qiuj
     * @Description:    柜子
     * @Date: 2020-06-26 15:20
     */
    public class Cabinet {
        //  柜子里存放的数字
        private Integer number;
    
        public Integer getNumber() {
            return number;
        }
    
        public synchronized void setNumber(Integer number) {
            this.number = number;
        }
    }
    

    我们在set方法上加了 synchronized 关键字,这样在赋值数字的时候就只会让有锁的线程进入,就不会并行的去执行了,而是哪个用户抢到锁,哪个用户执行存储数字的方法。我们在运行一下main 方法,看看运行的结果:

    客户的编号:1柜子里的数字:2
    客户的编号:0柜子里的数字:2
    客户的编号:2柜子里的数字:2

    咦?! 结果还是混乱的,为什么?我再检查一下代码:

                executorService.execute(() -> {
                    User user = new User(cabinet,number);
                    user.useCabinet();
                    System.out.println("客户的编号:" + number + "柜子里的数字:" + cabinet.getNumber());
                });

    我们可以看到 user.useCabinet() 和 打印方法是两个语句,并没有保持原子性。也就是 useCabinet() 方法内它是上锁的,执行完方法走到 输出语句 也是上锁的 。但是不能确保哪个线程去执行。所以我们要保证 useCabinet() 和输出语句是在一个原子性里。

    我们使用 synchronized() 代码块 ,但是 synchronized 块里的对象使用谁的 ? user 还是 cabinet 。user 我们在每个线程初始化的时候,都新建了一个。所以总共有3 个 ,而 cabinet 只有一个 。所以 synchronized 要使用 cabinet 

    package com.bfxy.esjob;
    
    import com.bfxy.esjob.lock.Cabinet;
    import com.bfxy.esjob.lock.User;
    
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    /**
     * @Author: qiuj
     * @Description:
     * @Date: 2020-06-26 15:23
     */
    public class Tests {
        public static void main(String[] args) {
            //  只有一个柜子  有3个用户
            Cabinet cabinet = new Cabinet();
            //  创建线程池
            ExecutorService executorService = Executors.newFixedThreadPool(3);
            for (int i = 0; i < 3; i++) {
                final Integer number = i;
                executorService.execute(() -> {
                    User user = new User(cabinet,number);
                    synchronized (cabinet) {
                        user.useCabinet();
                        System.out.println("客户的编号:" + number + "柜子里的数字:" + cabinet.getNumber());
                    }
    
                });
            }
            executorService.shutdown();
        }
    }
    

    我们再去运行一下:

    客户的编号:0柜子里的数字:0
    客户的编号:2柜子里的数字:2
    客户的编号:1柜子里的数字:1

     由于我们加了  synchronized 块,保证了存储和取出的原子性 ,这样用户存储的数字,和取出的数字就对应上了。不会造成混乱。最后我们通过一张图实例整体情况

    如上图所示,线程A、线程B、 线程C 同时调用 Cabinet 类的 setNumber 方法,线程B 获得了锁,所以线程B 可以执行 setNumber 的方法,线程A 和 线程C 只能等待

    4:总结

    通过上面的场景与实例,我们可以了解多线程情况下,造成的变量值前后不一致的问题,以及锁的作用。在使用锁了之后,可以避免这种混乱的现象

  • 相关阅读:
    深度学习中的范数
    UML描述的模型中常见关系及表示方法
    tensorflow入门:CNN for MNIST
    tensorflow 梯度下降方法小结
    tensorflow dropout实现
    tensorflow xaiver初始化
    tensorflow入门:Neural Network for mnist
    tensorflow入门:Softmax Classication
    tensorflow入门:Logistic Regression
    Monitor关键字
  • 原文地址:https://www.cnblogs.com/blogspring/p/14191743.html
Copyright © 2011-2022 走看看