1、传统锁回顾（Jvm本地锁，MySQL悲观锁、乐观锁）

目录

    • 1.1 从减库存聊起
    • 1.2 环境准备
    • 1.3 简单实现减库存
    • 1.4 演示超卖现象
    • 1.5 jvm锁
    • 1.6 三种情况导致Jvm本地锁失效
      • 1、多例模式下，Jvm本地锁失效
      • 2、Spring的事务导致Jvm本地锁失效
      • 3、集群部署导致Jvm本地锁失效
    • 1.7 mysql锁演示
      • 1.7.1、一个sql
      • 1.7.2、悲观锁
      • 1.7.3、乐观锁
      • 1.7.4、mysql锁总结
    • 1.8 redis乐观锁
      • 1.8.1 引入redis
      • 1.8.2 redis乐观锁原理
      • 1.8.3 redis乐观锁解决超卖问题
      • 1.8.4 redis乐观锁的缺点

1.1 从减库存聊起

多线程并发安全问题最典型的代表就是超卖现象
库存在并发量较大情况下很容易发生超卖现象，一旦发生超卖现象，就会出现多成交了订单而发不了货的情况。

场景：商品S库存余量为5时，用户A和B同时来购买一个商品，此时查询库存数都为5，库存充足则开始减库存
用户A：update db_stock set stock = stock - 1 where id = 1
用户B：update db_stock set stock = stock - 1 where id = 1
并发情况下，更新后的结果可能是4，而实际的最终库存量应该是3才对 ！！

1.2 环境准备

建表语句：

CREATE TABLE `db_stock` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `product_code` varchar(255) DEFAULT NULL COMMENT '商品编号',
  `stock_code` varchar(255) DEFAULT NULL COMMENT '仓库编号',
  `count` int(11) DEFAULT NULL COMMENT '库存量',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

表中数据如下：
在这里插入图片描述

创建分布式锁demo工程：

目录结构
在这里插入图片描述
pom.xml

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.46</version>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.3.4</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

application.yml配置文件：

server.port=10010
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://192.168.239.11:3306/atguigu_distributed_lock
spring.datasource.username=root
spring.datasource.password=houchen

DistributedLockApplication启动类：

@SpringBootApplication
@MapperScan("com.atguigu.distributed.lock.mapper")
public class DistributedLockApplication {

    public static void main(String[] args) {
        SpringApplication.run(DistributedLockApplication.class, args);
    }

}

Stock实体类：

@Data
@TableName("db_stock")
public class Stock {

    @TableId
    private Long id;

    private String productCode;

    private String stockCode;

    private Integer count;
}

StockMapper接口：

public interface StockMapper extends BaseMapper<Stock> {
}

1.3 简单实现减库存

在这里插入图片描述

@RestController
public class StockController {

    @Autowired
    private StockService stockService;

    @GetMapping("stock/deduct")
    public String deduct(){
        this.stockService.deduct();
        return "hello stock deduct！！";
    }

}

@Service
public class StockService {

    @Autowired
    private StockMapper stockMapper;

    public void  deduct(){
        // 先查询库存是否充足
        Stock stock = this.stockMapper.selectById(1L);
        // 再减库存
        if (stock != null && stock.getCount() > 0){
            stock.setCount(stock.getCount() - 1);
            this.stockMapper.updateById(stock);
        }
    }
}

测试：
在这里插入图片描述

查看数据库：
在这里插入图片描述

在浏览器中一个一个访问时，每访问一次，库存量减1，没有任何问题。

1.4 演示超卖现象

使用jmeter压力测试工具，高并发下压测一下，添加线程组：并发100循环50次，即5000次请求。
在这里插入图片描述
在这里插入图片描述

启动测试，查看压力测试报告：
在这里插入图片描述

  • Label 取样器别名，如果勾选Include group name ，则会添加线程组的名称作为前缀
  • # Samples 取样器运行次数
  • Average 请求（事务）的平均响应时间
  • Median 中位数
  • 90% Line 90%用户响应时间
  • 95% Line 90%用户响应时间
  • 99% Line 90%用户响应时间
  • Min 最小响应时间
  • Max 最大响应时间
  • Error 错误率
  • Throughput 吞吐率
  • Received KB/sec 每秒收到的千字节
  • Sent KB/sec 每秒收到的千字节

查看mysql数据库剩余库存数：还有4818
在这里插入图片描述

1.5 jvm锁

使用jvm锁（synchronized关键字或者ReetrantLock）试试：

 /**
     *  使用jvm锁来解决超卖问题
     */
    public synchronized void deduct() {
        // 先查询库存是否充足
        Stock stock = this.stockMapper.selectById(1L);
        // 再减库存
        if (stock != null && stock.getCount() > 0) {
            stock.setCount(stock.getCount() - 1);
            this.stockMapper.updateById(stock);
        }
    }

重启tomcat服务，再次使用jmeter压力测试，效果如下：
在这里插入图片描述
可以看到，加锁之后，吞吐量减少了一倍多！

查看mysql数据库：
在这里插入图片描述
并没有发生超卖现象，完美解决。

原理
添加synchronized关键字之后，同一时刻只有一个请求能够获取到锁，并减库存。此时，所有请求只会one-by-one执行下去，也就不会发生超卖现象
在这里插入图片描述

1.6 三种情况导致Jvm本地锁失效

1、多例模式下，Jvm本地锁失效

原理：StockService有多个对象，不同的对象持有不同的锁，所以还是会有多个线程进入到 临界区 中

演示：

@Service
@Scope(value = "prototype",proxyMode = ScopedProxyMode.TARGET_CLASS)
public class StockService {

    @Autowired
    private StockMapper stockMapper;

    /**
     *  使用jvm锁来解决超卖问题
     */
    public synchronized void deduct() {
        // 先查询库存是否充足
        Stock stock = this.stockMapper.selectById(1L);
        // 再减库存
        if (stock != null && stock.getCount() > 0) {
            stock.setCount(stock.getCount() - 1);
            this.stockMapper.updateById(stock);
        }
    }
}

重启tomcat服务，再次使用jmeter压力测试，查看数据库，发现库存确实没有减到 0 ，发生超卖
在这里插入图片描述

2、Spring的事务导致Jvm本地锁失效

在加锁的地方加上 @Transactional 注解

 @Transactional
    public synchronized void deduct() {
        // 先查询库存是否充足
        Stock stock = this.stockMapper.selectById(1L);
        // 再减库存
        if (stock != null && stock.getCount() > 0) {
            stock.setCount(stock.getCount() - 1);
            this.stockMapper.updateById(stock);
        }
    }

重启tomcat服务，再次使用jmeter压力测试，查看数据库，发现库存确实没有减到 0 ，发生超卖
在这里插入图片描述

造成超卖的原因：
Spring事务默认的隔离级别是可重复读
在这里插入图片描述

解决办法
扩大锁的范围，将开启事务，提交事务也包括在锁的代码块中

 @GetMapping("stock/deduct")
    public String deduct(){
        synchronized (this) {
            this.stockService.deduct();
        }
        return "hello stock deduct！！";
    }

3、集群部署导致Jvm本地锁失效

使用jvm锁在单工程单服务情况下确实没有问题，但是在集群情况下会怎样？

接下启动多个服务并使用nginx负载均衡

1）启动两个服务（端口号分别10010 10086），如下：
在这里插入图片描述

2）配置nginx 负载均衡

#user  nobody;
worker_processes  1;

#error_log  logs/error.log;
#error_log  logs/error.log  notice;
#error_log  logs/error.log  info;

#pid        logs/nginx.pid;


events {
    worker_connections  1024;
}


http {
    include       mime.types;
    default_type  application/octet-stream;
    sendfile        on;
	
	upstream distributed {
		server localhost:10010;
		server localhost:10086;
	}

    server {
        listen       80;
        server_name  localhost;
		location / {
			proxy_pass http://distributed;
		}
    }
}

3）在post中测试：http://localhost/stock/deduct （其中80是nginx的监听端口）
在这里插入图片描述
请求正常，说明nginx负载均衡起作用了

4） Jmeter压力测试
注意

  • 先把数据库库存量还原到5000
  • 重新配置访问路径 http://localhost:80/stock/deduct
    在这里插入图片描述
    两台机器时，吞吐量明显大于单个机器

查看数据库，库存不为0，表示多服务时，Jvm锁失效
在这里插入图片描述

5） 原因
每个服务都有自己的本地锁，所以无法锁住临界区，导致多线程的安全问题

1.7 mysql锁演示

除了使用jvm锁之外，还可以使用mysql自带的锁：悲观锁 或者 乐观锁

1.7.1、一个sql

update db_stock set count = count - 1 where product_code = '1001' and count >= #{count}

public void deduct() {
        this.stockMapper.updateStock("1001", 1);
    }
    
 public interface StockMapper extends BaseMapper<Stock> {
    @Update("update db_stock set count = count - #{count} where product_code = #{productCode} and count >= #{count}")
    int updateStock(@Param("productCode") String productCode, @Param("count") Integer count);
}

这种方式可以解决上述Jvm锁失效的三个问题

缺点：
1、确定好锁范围
当使用的是表锁时，会导致系统的吞吐量直线下降

​ 什么情况下会使用行级锁

​ 1）锁的查询或者更新条件必须是索引字段

​ 2） 查询或者更新条件必须是具体值

2、一件商品多个仓库问题无法处理

3、无法记录仓库变化前后的状态

1.7.2、悲观锁

SELECT ... FOR UPDATE                     （悲观锁）

代码实现

改造StockService： 添加事务注解，去掉synchronized关键词

@Transactional
    public void deduct() {
        Stock stocks = this.stockMapper.queryStockForUpdate("1001");
        if (stocks != null && stocks.getCount() > 0) {
            stocks.setCount(stocks.getCount() - 1);
            this.stockMapper.updateById(stocks);
        }
    }

在StockeMapper中定义selectStockForUpdate方法：

public interface StockMapper extends BaseMapper<Stock> {


    @Update("update db_stock set count = count - #{count} where product_code = #{productCode} and count >= #{count}")
    int updateStock(@Param("productCode") String productCode, @Param("count") Integer count);

    @Select("select * from db_stock where product_code = #{productCode} for update")
    Stock queryStockForUpdate(@Param("productCode") String productCode);
}

压力测试
注意：测试之前，需要把库存量改成5000。压测数据如下：比jvm锁性能高很多
在这里插入图片描述
mysql数据库存：
在这里插入图片描述

【注意】使用MySQL乐观锁时，也需要注意锁的粒度，尽量使用行级锁，否则系统吞吐量会降低

1.7.3、乐观锁

乐观锁是相对悲观锁而言，乐观锁假设认为数据一般情况下不会造成冲突，所以在数据进行提交更新的时候，才会正式对数据的冲突与否进行检测，如果发现冲突了，则重试。

使用数据版本（Version）记录机制实现，这是乐观锁最常用的实现 方式。一般是通过为数据库表增加一个数字类型的 “version” 字段来实现。当读取数据时，将version字段的值一同读出，数据每更新一次，对此version值加一。当我们提交更新的时候，判断数据库表对应记录的当前版本信息与第一次取出来的version值进行比对，如果数据库表当前版本号与第一次取出来的version值相等，则予以更新。

给db_stock表添加version字段：
在这里插入图片描述

改造 StockService

  /**
     *  使用MySQL乐观锁来解决库存超卖问题
     */
    public void deduct() {
        // 先查询库存是否充足
        Stock stock = this.stockMapper.selectById(1L);
        // 再减库存
        if (stock != null && stock.getCount() > 0){
            // 获取版本号
            Long version = stock.getVersion();

            stock.setCount(stock.getCount() - 1);
            // 每次更新 版本号 + 1
            stock.setVersion(stock.getVersion() + 1);
            // 更新之前先判断是否是之前查询的那个版本，如果不是重试
            if (this.stockMapper.update(stock, new UpdateWrapper<Stock>().eq("id", stock.getId()).eq("version", version)) == 0) {
                deduct();
            }
        }
    }

重启后使用jmeter压力测试工具结果如下：
在这里插入图片描述
在这里插入图片描述
并发度比较低，说明乐观锁在并发量越大的情况下，性能越低（因为需要大量的重试）；并发量越小，性能越高。

乐观锁存在的问题

  • 高并发情况下，性能较低
  • ABA问题
  • 读写分离的情况下，可能会导致乐观锁不可靠

1.7.4、mysql锁总结

性能：一个sql > 悲观锁 > jvm锁 > 乐观锁

  • 如果追求极致性能、业务场景简单并且不需要记录数据前后变化的情况下。

​ 优先选择：一个sql

  • 如果写并发量较低（多读），争抢不是很激烈的情况下优先选择：乐观锁

  • 如果写并发量较高，一般会经常冲突，此时选择乐观锁的话，会导致业务代码不间断的重试。

​ 优先选择：mysql悲观锁

  • 不推荐jvm本地锁。

1.8 redis乐观锁

1.8.1 引入redis

见我的博客 https://blog.csdn.net/hc1285653662/article/details/127564372 中的SpringDataRedis客户端

改造StockService

  /**
     * 为了提高请求响应的速度，将库存放在redis中进行操作
     */
    public void deduct() {
        // 先查询库存是否充足
        String stockStr = redisTemplate.opsForValue().get("stock:" + "1001");
        Long stock = Long.parseLong(stockStr);
        if (stock != null && stock > 0) {
            redisTemplate.opsForValue().set("stock:" + "1001", String.valueOf(stock - 1));
        }
    }

演示redis库存超卖
设置redis库存为 5000
在这里插入图片描述
jmeter启动测试，可以看到并发比无锁时候的mysql库存要高
在这里插入图片描述
查询redis库存，发现剩余库存不为0，所以发生超卖现象
在这里插入图片描述

1.8.2 redis乐观锁原理

使用watch命令监视某个key，如果在监视的过程中该key被某个客户端修改后，那么自身对于key的修改将会失败
在这里插入图片描述

1.8.3 redis乐观锁解决超卖问题

改造StockService

/**
     * 为了提高请求响应的速度，将库存放在redis中进行操作
     */
    public void deduct() {
        // 监听 stock:1001
        redisTemplate.execute(new SessionCallback<Object>() {
            @Override
            public Object execute(RedisOperations operations) throws DataAccessException {
                operations.watch("stock:" + "1001");
                String stockStr = (String) operations.opsForValue().get("stock:" + "1001");
                Long stock = Long.parseLong(stockStr);
                if (stock != null && stock > 0) {
                    operations.multi();
                    operations.opsForValue().set("stock:" + "1001", String.valueOf(stock - 1));
                    List exec = operations.exec();
                    // 如果减库存失败，代表key别其他客户端修改了，则进行重试
                    if (exec == null || exec.size() == 0) {
                        try {
                            Thread.sleep(50);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        deduct();
                    }
                    return exec;
                }
                return null;
            }
        });
    }

查看测试结果：发现并发很低（可能因为我redis部署在阿里云上的docker里，网络开销导致并发很低），但是确实解决超卖问题
在这里插入图片描述
在这里插入图片描述

1.8.4 redis乐观锁的缺点

  • 性能问题

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/46311.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

fragment

fragment

fragment 在vue2中,组件必须有一个跟标签在vue3中,组件可以没有跟标签,内部会将多个标签包含在一个fragment虚拟元素中好处:减少标签层级,减小内存占用 teltport 什么是teltport teleport是一种能够将我们组件html结构移动到指定位置的技术 像是下面的代码不适用teleport:…
阅读更多...
信息系统项目管理师（第四版）教材精读思维导图-第三章信息系统治理

信息系统项目管理师（第四版）教材精读思维导图-第三章信息系统治理

请参阅我的另一篇文章&#xff0c;综合介绍软考高项&#xff1a; 信息系统项目管理师&#xff08;软考高项&#xff09;备考总结_计算机技术与软件专业技术_铭记北宸的博客-CSDN博客 目录 3.1 IT治理 3.2 IT审计 3.1 IT治理 3.2 IT审计
阅读更多...
Java程序设计六大原则设计模式

Java程序设计六大原则设计模式

Java程序设计六大原则 一、单一职责原则&#xff1a; 一个接口或者类只有一个原因引起变化&#xff0c;即一个接口或者类只有一个职责&#xff0c;负责一件事情。&#xff08;此原则同样适用于方法&#xff09; 好处&#xff1a;1、复杂性降低&#xff1b;2、可读性提高&…
阅读更多...
elasticsearch查询操作（API方式）

elasticsearch查询操作（API方式）

说明&#xff1a;elasticsearch查询操作除了使用DSL语句的方式&#xff08;参考&#xff1a;http://t.csdn.cn/k7IGL&#xff09;&#xff0c;也可以使用API的方式。 准备 使用前需先导入依赖 <!--RestHighLevelClient依赖--><dependency><groupId>org.ela…
阅读更多...
内存泄漏是什么？有什么危害

内存泄漏是什么？有什么危害

内存泄漏是什么&#xff1f;有什么危害 1. 前言1.内存泄漏是什么&#xff1f;2. 为什么会发生内存泄漏3. 内存泄漏的危害4. 总结 1. 前言 在各种项目开发中&#xff0c;内存泄漏是一个很严重的问题。对资源管理、性能优越、系统稳定性&#xff0c;以及是否安全产生极大印象。本…
阅读更多...
AndroidStudio设计一个计算器

AndroidStudio设计一个计算器

界面设计 activity_calcuator.xml 设计&#xff1a; <?xml version"1.0" encoding"utf-8"?> <LinearLayout xmlns:android"http://schemas.android.com/apk/res/android"xmlns:app"http://schemas.android.com/apk/res-auto&qu…
阅读更多...
2、基于redis实现分布式锁

2、基于redis实现分布式锁

目录 2.1. 基本实现2.2. 防死锁2.3. 防误删2.4. redis中的lua脚本2.4.1 redis 并不能保证2.4.2 lua介绍 2.5. 使用lua保证删除原子性 2.1. 基本实现 借助于redis中的命令setnx(key, value)&#xff0c;key不存在就新增&#xff0c;存在就什么都不做。同时有多个客户端发送setn…
阅读更多...
Easy-Es笔记

Easy-Es笔记

一、Easy-ES概述 Easy-Es&#xff08;简称EE&#xff09;是一款由国内开发者打造并完全开源的ElasticSearch-ORM框架。在原生 RestHighLevelClient 的基础上&#xff0c;只做增强不做改变&#xff0c;为简化开发、提高效率而生。Easy-Es采用和MP一致的语法设计&#xff0c;降低…
阅读更多...
HDFS异构存储详解

HDFS异构存储详解

异构存储 HDFS异构存储类型什么是异构存储异构存储类型如何让HDFS知道集群中的数据存储目录是那种类型存储介质 块存储选择策略选择策略说明选择策略的命令 案例&#xff1a;冷热温数据异构存储对应步骤 HDFS内存存储策略支持-- LAZY PERSIST介绍执行使用 HDFS异构存储类型 冷…
阅读更多...
C# winform子窗口向父窗口传值

C# winform子窗口向父窗口传值

这里我使用一个简单的方法。只需要在父窗口定义一个静态变量就行。 父窗体为Form1,子窗体为Form2。 public static int get_num0; 子窗体直接给get_num赋值即可。 Form1.get_num2; 这样父窗体就能获得get_num修改后这个值了
阅读更多...
[start] m40 test

[start] m40 test

software & update 470 drive version # cd /etc/apt # mv sources.list sources.list.bak # sudo vi /etc/apt/sources.list # 默认注释了源码镜像以提高 apt update 速度&#xff0c;如有需要可自行取消注释 deb https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ ja…
阅读更多...
Flask 笔记

Flask 笔记

Flask 笔记 一、Flask介绍 1、学习Flask框架的原因 2020 Python 开发者调查结果显示Flask和Django是Python Web开发使用的最主要的两个框架。 2、Flask介绍 ​ Flask诞生于2010年&#xff0c;是Armin ronacher用Python 语言基于Werkzeug工具箱编写的轻量级Web开发框架。 ​…
阅读更多...
Linux--vscode打开命令行端口的快捷键

Linux--vscode打开命令行端口的快捷键

快捷键&#xff1a;Ctrl~
阅读更多...
Matlab 点云平面特征提取

Matlab 点云平面特征提取

文章目录 一、简介二、实现代码2.1基于k个邻近点2.2基于邻近半径参考资料一、简介 点云中存在这各种各样的几何特征，这里基于每个点的邻域协方差来获取该点的所具有的基础几何特征（如下图所示），这样的做法虽然不能很好的提取出点云中的各个部分，但却是可以作为一种数据预处…
阅读更多...
SAP ABAP 用户状态锁定案例

SAP ABAP 用户状态锁定案例

一、前言 项目需求是根据当天及前两天的离职员工信息&#xff08;假设这是一个定时器任务每天下午5点执行程序&#xff0c;计算前两天的员工工号是为了将5点之后办理离职的员工工号找出来&#xff09;&#xff0c;将这些员工在用户表 USR02 中的锁定状态设置为 “64”&#xff…
阅读更多...
Emacs之实现鼠标/键盘选中即拷贝外界内容(一百二十)

Emacs之实现鼠标/键盘选中即拷贝外界内容(一百二十)

简介&#xff1a; CSDN博客专家&#xff0c;专注Android/Linux系统&#xff0c;分享多mic语音方案、音视频、编解码等技术&#xff0c;与大家一起成长&#xff01; 优质专栏&#xff1a;Audio工程师进阶系列【原创干货持续更新中……】&#x1f680; 人生格言&#xff1a; 人生…
阅读更多...
springboot整合ELK+kafka采集日志

springboot整合ELK+kafka采集日志

一、背景介绍 在分布式的项目中&#xff0c;各功能模块产生的日志比较分散&#xff0c;同时为满足性能要求&#xff0c;同一个微服务会集群化部署&#xff0c;当某一次业务报错后&#xff0c;如果不能确定产生的节点&#xff0c;那么只能逐个节点去查看日志文件&#xff1b;lo…
阅读更多...
SecureCRT如何将复制的内容粘贴到word中仍然保持原有字体颜色

SecureCRT如何将复制的内容粘贴到word中仍然保持原有字体颜色

SecureCRT如何将复制的内容粘贴到word中仍然保持原有字体颜色 QQ 109792317 说明&#xff1a;当SecureCRT加载了配色文件后&#xff0c;输出的关键字会被不同颜色高亮显示&#xff0c;但是如果复制粘贴到word中会发现成了纯文本&#xff0c;字体颜色消失了。 如何保留 &#x…
阅读更多...
2.java语法

2.java语法

文章目录 2.1. 字符型常量和字符串常量的区别?2.2. 关于注释&#xff1f;2.3. 标识符和关键字的区别是什么&#xff1f;2.4. Java 中有哪些常见的关键字&#xff1f; 2.5. 自增自减运算符2.6. continue、break、和 return 的区别是什么&#xff1f; 2.1. 字符型常量和字符串常…
阅读更多...
CCLINK转profinet与西门子PLC通讯

CCLINK转profinet与西门子PLC通讯

用三菱PLC的控制系统需要和西门子的PLC控制系统交互数据&#xff0c;捷米JM-PN-CCLK 是自主研发的一款 PROFINET 从站功能的通讯网关。该产品主要功能是将各种 CCLINK 总线和 PROFINET 网络连接起来。 捷米JM-PN-CCLK总线中做为从站使用&#xff0c;连接到 CCLINK 总线中做为…
阅读更多...
最新文章

Copyright @ 2022~2023