docker 安装红锁实现分布式锁方式

2022-08-22 22:32:34 阅读：175 来源： 互联网

标签：orderId 红锁 int driverId redis conf docker order 分布式

1 docker pull redis
拉取镜像 redis 
2 创建redis 映射配置文件（也就是挂在目录）
mkdir -p /mydata/redis/conf
3 下载redis.conf 文件
wget http://download.redis.io/redis-stable/redis.conf
4 修改conf 文件内容

bind 127.0.0.1 # 这行要注释掉，解除本地连接限制
protected-mode no # 默认yes，如果设置为yes，则只允许在本机的回环连接，其他机器无法连接。
daemonize no # 默认no 为不守护进程模式，docker部署不需要改为yes，docker run -d本身就是后台启动，不然会冲突
requirepass 123456 # 设置密码（可以不设置）
appendonly yes # 持久化

5 复制conf 文件 重新命名 为redis6380.conf,redis6381.conf,redis6382.conf
除了 port 不同 其他均相同
docker run -p 6380:6380 --name order01 -v /mydata/redis/conf/redis6380.conf:/etc/redis/redis6380.conf  -v /mydata/redis/data:/data -d redis redis-server /etc/redis/redis6380.conf --appendonly yes
docker run -p 6381:6381 --name order02 -v /mydata/redis/conf/redis6381.conf:/etc/redis/redis6381.conf  -v /mydata/redis/data:/data -d redis redis-server /etc/redis/redis6381.conf --appendonly yes
docker run -p 6382:6382 --name order03 -v /mydata/redis/conf/redis6382.conf:/etc/redis/redis6382.conf  -v /mydata/redis/data:/data -d redis redis-server /etc/redis/redis6382.conf --appendonly yes

我们创建了三个不同的redis 实例

然后我们需要配置红锁我们需要导入一下两个依赖

　　　　 <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson</artifactId>
            <version>3.3.2</version>
        </dependency>

我们需要实现的功能如下：
  多个司机 同时抢一个订单,在多个订单服务中,只有一个司机能抢到,
因此我们需要依赖分布式锁来实现   具体就是redisson的红锁

DROP TABLE IF EXISTS `tbl_order`;
CREATE TABLE `tbl_order` (
  `order_id` int(8) NOT NULL,
  `order_status` int(8) DEFAULT NULL,
  PRIMARY KEY (`order_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of tbl_order
-- ----------------------------
INSERT INTO `tbl_order` VALUES ('1', '1');

DROP TABLE IF EXISTS `tbl_order_lock`;
CREATE TABLE `tbl_order_lock` (
  `order_id` int(8) NOT NULL,
  `driver_id` int(8) DEFAULT NULL,
  PRIMARY KEY (`order_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

当多个司机抢一个订单,抢到订单的司机会将order_status 改为1 并输出抢订单成功其他没有抢到订单的司机则输出抢订单失败

     @Component
     public class RedisConfig {
    /*红锁  */
    @Bean(name = "redissonClient01")
    public RedissonClient redissonClient01(){
        Config config = new Config();
        config.useSingleServer().setAddress("192.168.0.137:6380").setDatabase(0);
        RedissonClient redissonClient1 = Redisson.create(config);
        return redissonClient1;
    }
    @Bean(name = "redissonClient02")
    public RedissonClient redissonClient02(){
        Config config = new Config();
        config.useSingleServer().setAddress("192.168.0.137:6381").setDatabase(0);
        RedissonClient redissonClient2 = Redisson.create(config);
        return redissonClient2;
    }
    @Bean(name = "redissonClient03")
    public RedissonClient redissonClient03(){
        Config config = new Config();
        config.useSingleServer().setAddress("192.168.0.137:6382").setDatabase(0);
        RedissonClient redissonClient3 = Redisson.create(config);
        return redissonClient3;
    }
}

@RestController
@RequestMapping("/grab")
public class GrabOrderController {
    @Autowired
    GrabService grabService;
    @GetMapping("/do/{orderId}")
    public String grab(@PathVariable("orderId")int orderId,int driverId){
        System.out.println("orderId:"+orderId+",driverId:"+driverId);
        grabService.grab(orderId,driverId);
        return "";
    }
}

@Service
public class GrabServiceImpl implements GrabService {
    @Autowired
    private RedisConfig redisConfig;
    @Autowired
    TblOrderService tblOrderService;

    /*红锁实现分布式锁*/
    @Override
    public void grab(int orderId, int driverId) {
        /*生成订单key*/
        String RedLockKey = (RedisKeyConstant.GRAB_LOCK_ORDER_KEY_PRE + orderId).intern();
        RLock lock01 = redisConfig.redissonClient01().getLock(RedLockKey);
        RLock lock02 = redisConfig.redissonClient02().getLock(RedLockKey);
        RLock lock03 = redisConfig.redissonClient03().getLock(RedLockKey);
        // 同时加锁：lock01 lock02 lock03
        RedissonRedLock lock = new RedissonRedLock(lock01, lock02, lock03);
        // 红锁在大部分节点上加锁成功就算成功。
        try {
            lock.lock();
            try {
               /* TimeUnit.MINUTES.sleep(1);*/
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println("司机:"+driverId+" 执行抢单逻辑");
            /*抢到锁的司机 修改订单状态 为1 */
            boolean grab = tblOrderService.grab(orderId, driverId);
            if(grab){
                System.out.println("司机:"+driverId+" 抢单成功");
                /*就把该司机的driverid 和 订单id 绑定在一起*/
            }else {
                System.out.println("司机:"+driverId+" 抢单失败");
            }
        }
        finally {
            lock.unlock();
        }

    }
}

    @Override
    public boolean grab(int orderId, int driverId) {
        TblOrderEntity order = tblOrderDao.selectById(orderId);

        if(order.getOrderStatus().intValue()==0){
                order.setOrderStatus(1);
                tblOrderDao.updateById(order);
                return true;
        }else
            return false;
    }
}

为了测试我们启动两个service-order 服务来提供测试

启动一台后修改端口再次启动该服务

然后我们需要一个api 接口服务来调用我们创建好的这两个服务

我们利用openFeign 来远程调用service-order 这两个服务（loadbalancer）请求消息会均摊到这两个服务上去

用Jmeter 测试一次1秒发送10条消息每条消息的orderId 相同但是driverId不同（我们引入Jmeter自带的计数器来实现driverId的自增）来模拟多个司机在同一时间堆同一订单进行抢单操作

因为涉及到的是分布式锁我们使用的redsson 的红锁来实现分布式锁

标签：orderId,红锁,int,driverId,redis,conf,docker,order,分布式
来源： https://www.cnblogs.com/Lcch/p/16614476.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

docker 安装 红锁 实现分布式锁方式

docker 安装红锁实现分布式锁方式