KittyDaddy's blog KittyDaddy's blog
首页
  • 学习笔记

    • 《Java基础》
    • 《常用设计模式》
    • 《MYSQL》
    • 《GO语言》
    • 《Spring源码解读》
  • 微服务解决方案

    • 锁的演化
    • 简单限流方案
    • 海量数据切分
  • 中间件

    • Nginx
    • MQ
    • Redis
    • Keepalived
  • 面试记
  • 杂文
  • 开源
  • 友情链接
关于
收藏
  • 分类
  • 标签
  • 归档
GitHub (opens new window)

老猫

万物皆系统
首页
  • 学习笔记

    • 《Java基础》
    • 《常用设计模式》
    • 《MYSQL》
    • 《GO语言》
    • 《Spring源码解读》
  • 微服务解决方案

    • 锁的演化
    • 简单限流方案
    • 海量数据切分
  • 中间件

    • Nginx
    • MQ
    • Redis
    • Keepalived
  • 面试记
  • 杂文
  • 开源
  • 友情链接
关于
收藏
  • 分类
  • 标签
  • 归档
GitHub (opens new window)
  • 什么是锁
    • 锁的演化-Java中锁的解决方案
    • 锁的演化-单体架构实战案例
    • 锁的演化-分布式锁实战-MYSQL篇
    • 锁的演化-分布式锁实战-REDIS篇
    • 锁的演化-分布式锁实战-ZOOKEEPER篇
    • 《锁的演化》
    老猫
    2020-11-13
    目录
    描述
    抽象成代码
    总结

    什么是锁原创

    从本篇开始,我们来好好梳理一下Java开发中的锁,通过一些具体简单的例子来描述清楚从Java单体锁到分布式锁的演化流程。本篇我们先来看看什么是锁,以下老猫会通过一些日常生活中的例子也说清楚锁的概念。

    tes

    # 描述

    锁在Java中是一个非常重要的概念,在当今的互联网时代,尤其在各种高并发的情况下,我们更加离不开锁。那么到底什么是锁呢?在计算机中,锁(lock)或者互斥(mutex)是一种同步机制,用于在有许多执行线程的环境中强制对资源的访问限制。锁可以强制实施排他互斥、并发控制策略。举一个生活中的例子,大家都去超市买东西,如果我们带了包的话,要放到储物柜。我们再把这个例子极端一下,假如柜子只有一个,那么此时同时来了三个人A、B、C都要往这个柜子里放东西。那么这个场景就是一个多线程,多线程自然也就离不开锁。简单示意图如下

    存储柜子

    A、B、C都要往柜子里面放东西,可是柜子只能存放一个东西,那么怎么处理?这个时候我们就引出了锁的概念,三个人中谁先抢到了柜子的锁,谁就可以使用这个柜子,其他的人只能等待。比如C抢到了锁,C就可以使用这个柜子,A和B只能等待,等到C使用完毕之后,释放了锁,AB再进行抢锁,谁先抢到了,谁就有使用柜子的权利。

    # 抽象成代码

    我们其实可以将以上场景抽象程相关的代码模型,我们来看一下以下代码的例子。

    /**
     * @author kdaddy@163.com
     * @date 2020/11/2 23:13
     */
    public class Cabinet {
        //表示柜子中存放的数字
        private int storeNumber;
    
        public int getStoreNumber() {
            return storeNumber;
        }
        public void setStoreNumber(int storeNumber) {
            this.storeNumber = storeNumber;
        }
    }
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15

    柜子中存储的是数字。

    然后我们把3个用户抽象成一个类,如下代码

    /**
     * @author kdaddy@163.com
     * @date 2020/11/7 22:03
     */
    public class User {
        // 柜子
        private Cabinet cabinet;
        // 存储的数字
        private int storeNumber;
    
        public User(Cabinet cabinet, int storeNumber) {
            this.cabinet = cabinet;
            this.storeNumber = storeNumber;
        }
        // 表示使用柜子
        public void useCabinet(){
            cabinet.setStoreNumber(storeNumber);
        }
    }
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19

    在用户的构造方法中,需要传入两个参数,一个是要使用的柜子,另一个是要存储的数字。以上我们把柜子和用户都已经抽象完毕,接下来我们再来写一个启动类,模拟一下3个用户使用柜子的场景。

    /**
     * @author kdaddy@163.com
     * @date 2020/11/7 22:05
     */
    public class Starter {
        public static void main(String[] args) {
            final Cabinet cabinet = new Cabinet();
            ExecutorService es = Executors.newFixedThreadPool(3);
    
            for(int i= 1; i < 4; i++){
                final int storeNumber = i;
                es.execute(()->{
                    User user = new User(cabinet,storeNumber);
                    user.useCabinet();
                    System.out.println("我是用户"+storeNumber+",我存储的数字是:"+cabinet.getStoreNumber());
                });
            }
            es.shutdown();
        }
    }
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20

    我们仔细的看一下这个main函数的过程

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

    我们运行一下main函数,看看得到的打印结果是什么?

    我是用户1,我存储的数字是:3
    我是用户3,我存储的数字是:3
    我是用户2,我存储的数字是:2
    
    1
    2
    3

    从结果中,我们可以看出三个用户在存储数字的时候两个都是3,一个是2。这是为什么呢?我们期待的应该是每个人都能获取不同的数字才对。其实问题就是出在"user.useCabinet();"这个方法上,这是因为柜子这个实例没有加锁的原因,三个用户并行执行,向柜子中存储他们的数字,虽然3个用户并行同时操作,但是在具体赋值的时候,也是有顺序的,因为变量storeNumber只有一块内存,storeNumber只存储一个值,存储最后的线程所设置的值。至于哪个线程排在最后,则完全不确定,赋值语句执行完成之后,进入打印语句,打印语句取storeNumber的值并打印,这时storeNumber存储的是最后一个线程锁所设置的值,3个线程取到的值有两个是相同的,就像上面打印的结果一样。

    那么如何才能解决这个问题?这就需要我们用到锁。我们再赋值语句上加锁,这样当多个线程(此处表示用户)同时赋值的时候,谁能优先抢到这把锁,谁才能够赋值,这样保证同一个时刻只能有一个线程进行赋值操作,避免了之前的混乱的情况。

    那么在程序中,我们如何加锁呢?

    下面我们介绍一下Java中的一个关键字synchronized。关于这个关键字,其实有两种用法。

    • synchronized方法,顾名思义就是把synchronize的关键字写在方法上,它表示这个方法是加了锁的,当多个线程同时调用这个方法的时候,只有获得锁的线程才能够执行,具体如下:

      public synchronized String getTicket(){
              return "xxx";
          }
      
      1
      2
      3

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

    • synchronized代码块。如下:

      synchronized (对象锁){
          ……
      }
      
      1
      2
      3

      我们将需要加锁的语句都写在代码块中,而在对象锁的位置,需要填写加锁的对象,它的含义是,当多个线程并发执行的时候,只有获得你写的这个对象的锁,才能够执行后面的语句,其他的线程只能等待。synchronized块通常的写法是synchronized(this),这个this是当前类的实例,也就是说获得当前这个类的对象的锁,才能够执行这个方法,此写法等同于synchronized方法。

    回到刚才的例子中,我们又是如何解决storeNumber混乱的问题呢?咱们试着在方法上加上锁,这样保证同时只有一个线程能调用这个方法,具体如下。

    /**
     * @author kdaddy@163.com
     * @date 2020/12/2 23:13
     */
    public class Cabinet {
        //表示柜子中存放的数字
        private int storeNumber;
    
        public int getStoreNumber() {
            return storeNumber;
        }
    
        public synchronized void setStoreNumber(int storeNumber) {
            this.storeNumber = storeNumber;
        }
    }
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16

    我们运行一下代码,结果如下

    我是用户2,我存储的数字是:2
    我是用户3,我存储的数字是:2
    我是用户1,我存储的数字是:1
    
    1
    2
    3

    我们发现结果还是混乱的,并没有解决问题。我们检查一下代码

     es.execute(()->{
                    User user = new User(cabinet,storeNumber);
                    user.useCabinet();
                    System.out.println("我是用户"+storeNumber+",我存储的数是:"+cabinet.getStoreNumber());
                });
    
    1
    2
    3
    4
    5

    我们可以看到在useCabinet和打印的方法是两个语句,并没有保持原子性,虽然在set方法上加了锁,但是在打印的时候又存在了并发,打印语句是有锁的,但是不能确定哪个线程去执行。所以这里,我们要保证useCabinet和打印的方法的原子性,我们使用synchronized块,但是synchronized块里的对象我们使用谁的?这又是一个问题,user还是cabinet?回答当然是cabinet,因为每个线程都初始化了user,总共有3个User对象,而cabinet对象只有一个,所以synchronized要用cabine对象,具体代码如下

    /**
     * @author kdaddy@163.com
     * @date 2020/12/7 22:05
     */
    public class Starter {
        public static void main(String[] args) {
            final Cabinet cabinet = new Cabinet();
            ExecutorService es = Executors.newFixedThreadPool(3);
    
            for(int i= 1; i < 4; i++){
                final int storeNumber = i;
                es.execute(()->{
                    User user = new User(cabinet,storeNumber);
                    synchronized (cabinet){
                        user.useCabinet();
                        System.out.println("我是用户"+storeNumber+",我存储的数字是:"+cabinet.getStoreNumber());
                    }
                });
            }
            es.shutdown();
        }
    }
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22

    此时我们再去运行一下:

    我是用户3,我存储的数字是:3
    我是用户2,我存储的数字是:2
    我是用户1,我存储的数字是:1
    
    1
    2
    3

    由于我们加了synchronized块,保证了存储和取出的原子性,这样用户存储的数字和取出的数字就对应上了,不会造成混乱,最后我们用图来表示一下上面例子的整体情况。 最终模型

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

    # 总结

    通过上面的场景以及例子,我们可以了解多线程情况下,造成的变量值前后不一致的问题,以及锁的作用,在使用了锁以后,可以避免这种混乱的现象,后续,老猫会和大家介绍一个Java中都有哪些关于锁的解决方案,以及项目中所用到的实战。

    #分布式锁#什么是锁
    上次更新: 2023/11/06, 23:30:17
    锁的演化-Java中锁的解决方案

    锁的演化-Java中锁的解决方案→

    阅读全文
    最近更新
    01
    让大龄程序员欲罢不能的事儿
    09-23
    02
    运营明明设置了活动开始时间,为什么到点没生效?聊聊动态定时任务
    07-30
    03
    不是,大哥,咱这小门小户的,别搞我CDN流量啊
    07-25
    更多文章>

    1 评论
    免费机场 Chrome 115.0.0.0 Windows 11
    2024-02-28回复

    友链申请
    网站名称:免费机场
    网站链接:https://clashgithub.com
    网站头像:https://clashgithub.com/wp-content/uploads/avatar.png
    网站描述:免费公益SSR/V2ray/Shadowrocket/Clash节点/小火箭订阅链接|科学上网|免费梯子

    Powered By Valine
    v1.5.1
    Theme by Vdoing | Copyright © 2020-2025 Kitty Daddy | License
    • 跟随系统
    • 浅色模式
    • 深色模式
    • 阅读模式