分布锁-mysql，redis,zk

最新推荐文章于 2022-05-22 08:06:08 发布
最新推荐文章于 2022-05-22 08:06:08 发布
阅读量221 收藏 1
点赞数
分类专栏： 分布式锁
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lh87270202/article/details/102528118
版权

一、为什么要用到分布锁

1、多环境中才需要
2、任务都需要对同一共享资源时空行写操作
3、对资源访问互斥
锁竞争4个步骤：
1、竞争锁
2、占有锁
3、任务阻赛
4、释放锁

二、分布式锁几种方案及比较

在这里插入图片描述

在实现zk锁前，先简单说明一下模版方法模式
在父类中编排主流程，将步骤实现延迟到子类去实现。
比如下图：
在这里插入图片描述
在模版类中定义清点商品，计算价目，支付，送货上门主流程方法，并实现了清点商品，计算价目，送货上门方法，但在子中实现不同支付方法。

public abstract class AbstractTemplate {
    public void goumai(){
        shangPing();
        jiShuan();
        pay();
        fahuo();
    }
    public void shangPing(){
        System.out.println("清点商品");
    }
    public void jiShuan(){
        System.out.println("计算");
    }
    public void fahuo(){
        System.out.println("发货");
    }
    public abstract void pay();
}

public class WeiPayTemplate extends AbstractTemplate {
    @Override
    public void pay() {
        System.out.println("weipay");
    }

    public static void main(String[] args){
        WeiPayTemplate w = new WeiPayTemplate();
        w.goumai();
    }
}

那么我们实现锁也是这个过成程，在抽象类中定义获取锁，竞争锁，等待锁，释放锁
定义一lock类，Mysql redis zk子类都都继承这个抽象类具体在子类实现各自的方法。

1 、 mysql锁

新建一张表
method_Lock

CREATE TABLE `method_Lock` (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键',
  `method_name` varchar(64) NOT NULL DEFAULT '' COMMENT '锁定的方法名',
  `desc` varchar(1024) NOT NULL DEFAULT '备注信息',
  `update_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE,   
   current_timestamp COMMENT '保存数据时间，自动生成',
  PRIMARY KEY (`id`),
  UNIQUE KEY `uidx_method_name` (`method_name `) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='锁定中的方法';

当我们想要锁住某个方法时，执行以下SQL：

insert into method_Lock (method_name,desc) values (‘method_name’,‘desc’)

如果新增成功那么，获取锁成功，失败那么获取锁失败。
当方法执行完毕之后，想要释放锁的话，需要执行以下Sql:

delete from method_Lock where method_name ='method_name'

模版方法：

public abstract class AbstractLock implements Lock {
    public void getLock(){
        //1 、竞争锁
        if(tryLock()){
            System.out.print("##get lock锁的资源###");
        }else{
            //2、任务阻塞
            waitLock();
            //重新获取锁
            getLock();
        }
    }
    public abstract void waitLock();

    public abstract void unLock();

    public abstract boolean tryLock();
}

mysql锁实现类

@Service
public class MysqlLock extends AbstractLock {
    private static final int LOCK_ID = 1;
    @Autowired
    private LockMapper lockMapper;

    @Override
    //非阻塞式加锁
    public boolean tryLock() {
        try {
            lockMapper.insert(LOCK_ID);
        }catch (Exception e){
            return false;
        }
        return true;
    }
    //让当前线程休眠一段时间
    @Override
    public void waitLock() {
        try{
            Thread.currentThread().sleep(10);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
    //释放锁
    @Override
    public void unLock() {
        lockMapper.delete(LOCK_ID);
    }

}

调用

public class MysqlTest extends AbstratApplicationBaseBootTest {
    private static int i = 1;
    @Resource
    private MysqlLock mysqlLock;
    public void getNum(){
        try{
            mysqlLock.getLock();
            Date d = new Date();
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            System.out.println("当前时间：" + sdf.format(d));
            String date = sdf.format(d);
            System.out.println(Thread.currentThread().getName()+"生成订单号"+date+"  "+i);
            i = i+1;
        }finally {
            mysqlLock.unLock();
        }
    }

    @Test
    public void test() throws InterruptedException {
        System.out.println("生成唯一订单号");
        for(int i =1;i<=20;i++){
            new Thread(new Runnable() {
                @Override
                public void run() {
                    getNum();
                }
            }).start();
        }

        Thread.sleep(10000);

    }
}

结果：生成20个不同的订单号

##get lock锁的资源###当前时间：2019-10-13 01:51:42
Thread-28生成订单号2019-10-13 01:51:42  1
[2019-10-13 01:51:42,921] [Thread-15] [INFO ] org.springframework.beans.factory.xml.XmlBeanDefinitionReader 316 -- Loading XML bean definitions from class path resource [org/springframework/jdbc/support/sql-error-codes.xml]
[2019-10-13 01:51:42,975] [Thread-15] [INFO ] org.springframework.jdbc.support.SQLErrorCodesFactory 128 -- SQLErrorCodes loaded: [DB2, Derby, H2, HDB, HSQL, Informix, MS-SQL, MySQL, Oracle, PostgreSQL, Sybase]
##get lock锁的资源###当前时间：2019-10-13 01:51:43
Thread-22生成订单号2019-10-13 01:51:43  2
##get lock锁的资源###当前时间：2019-10-13 01:51:43
Thread-18生成订单号2019-10-13 01:51:43  3
##get lock锁的资源###当前时间：2019-10-13 01:51:43
Thread-24生成订单号2019-10-13 01:51:43  4
##get lock锁的资源###当前时间：2019-10-13 01:51:43
Thread-23生成订单号2019-10-13 01:51:43  5
##get lock锁的资源###当前时间：2019-10-13 01:51:43
Thread-16生成订单号2019-10-13 01:51:43  6
##get lock锁的资源###当前时间：2019-10-13 01:51:44
Thread-27生成订单号2019-10-13 01:51:44  7
##get lock锁的资源###当前时间：2019-10-13 01:51:44
Thread-30生成订单号2019-10-13 01:51:44  8
##get lock锁的资源###当前时间：2019-10-13 01:51:44
Thread-31生成订单号2019-10-13 01:51:44  9
##get lock锁的资源###当前时间：2019-10-13 01:51:44
Thread-33生成订单号2019-10-13 01:51:44  10
##get lock锁的资源###当前时间：2019-10-13 01:51:44
Thread-15生成订单号2019-10-13 01:51:44  11
##get lock锁的资源###当前时间：2019-10-13 01:51:44
Thread-19生成订单号2019-10-13 01:51:44  12
##get lock锁的资源###当前时间：2019-10-13 01:51:45
Thread-20生成订单号2019-10-13 01:51:45  13
##get lock锁的资源###当前时间：2019-10-13 01:51:45
Thread-25生成订单号2019-10-13 01:51:45  14
##get lock锁的资源###当前时间：2019-10-13 01:51:45
Thread-32生成订单号2019-10-13 01:51:45  15
##get lock锁的资源###当前时间：2019-10-13 01:51:45
Thread-34生成订单号2019-10-13 01:51:45  16
##get lock锁的资源###当前时间：2019-10-13 01:51:45
Thread-26生成订单号2019-10-13 01:51:45  17
##get lock锁的资源###当前时间：2019-10-13 01:51:45
Thread-29生成订单号2019-10-13 01:51:45  18
##get lock锁的资源###当前时间：2019-10-13 01:51:45
Thread-21生成订单号2019-10-13 01:51:45  19
##get lock锁的资源###当前时间：2019-10-13 01:51:46
Thread-17生成订单号2019-10-13 01:51:46  20

1.1、利用mysql实现的锁缺点：

性能差，最多并发量700~1000 ,差点的机器可以才100~200并发，满足不了大的并发需求
死锁，如果一个线程获取锁后，程序执行中断，那么锁没有释放，就会死锁
不优雅，查看wailLock这段代码，是休眠一段时间后再去获锁，没法在锁释放后自动监听锁被释放，而需要休眠一段时间 不断去查看锁是否被释放掉。
非阻塞的？需要自己搞一个while循环，直到insert成功再返回成功。或通过递归重复获取锁，直到成功才返回
这把锁强依赖数据库的可用性，数据库是一个单点，一旦数据库挂掉，会导致业务系统不可用。
这把锁是非重入的，同一个线程在没有释放锁之前无法再次获得该锁。因为数据中数据已经存在了。

我们也可以有其他方式解决上面的问题。

  • 数据库是单点？搞两个数据库，数据之前双向同步。一旦挂掉快速切换到备库上。
  • 没有失效时间？只要做一个定时任务，每隔一定时间把数据库中的超时数据清理一遍。
  • 非重入的？在数据库表中加个字段，记录当前获得锁的机器的主机信息和线程信息，那么下次再获取锁的时候先查询数据库，如果当前机器的主机信息和线程信息在数据库可以查到的话，直接把锁分配给他就可以了

1.2、基于数据库排他锁

除了可以通过增删操作数据表中的记录以外，其实还可以借助数据中自带的锁来实现分布式的锁。

我们还用刚刚创建的那张数据库表。可以通过数据库的排他锁来实现分布式锁。 基于MySql的InnoDB引擎，可以使用以下方法来实现加锁操作：

public boolean lock(){
    connection.setAutoCommit(false)
    while(true){
        try{
            result = select * from method_Lock where method_name=xxx for update;
            if(result==null){
                return true;
            }
        }catch(Exception e){

        }
        sleep(1000);
    }
    return false;
}

在查询语句后面增加for update，数据库会在查询过程中给数据库表增加排他锁（这里再多提一句，InnoDB引擎在加锁的时候，只有通过索引进行检索的时候才会使用行级锁，否则会使用表级锁。这里我们希望使用行级锁，就要给method_name添加索引，值得注意的是，这个索引一定要创建成唯一索引，否则会出现多个重载方法之间无法同时被访问的问题。重载方法的话建议把参数类型也加上。）。当某条记录被加上排他锁之后，其他线程无法再在该行记录上增加排他锁。

我们可以认为获得排它锁的线程即可获得分布式锁，当获取到锁之后，可以执行方法的业务逻辑，执行完方法之后，再通过以下方法解锁：

public void unlock(){
    connection.commit();
}

通过connection.commit()操作来释放锁。
这种方法可以有效的解决上面提到的无法释放锁和阻塞锁的问题。

  • 阻塞锁？ for update语句会在执行成功后立即返回，在执行失败时一直处于阻塞状态，直到成功。
  • 锁定之后服务宕机，无法释放？使用这种方式，服务宕机之后数据库会自己把锁释放掉。

但是还是无法直接解决数据库单点和可重入问题。

这里还可能存在另外一个问题，虽然我们对method_name 使用了唯一索引，并且显示使用for update来使用行级锁。但是，MySql会对查询进行优化，即便在条件中使用了索引字段，但是否使用索引来检索数据是由 MySQL 通过判断不同执行计划的代价来决定的，如果 MySQL 认为全表扫效率更高，比如对一些很小的表，它就不会使用索引，这种情况下 InnoDB 将使用表锁，而不是行锁。如果发生这种情况就悲剧了。。。

还有一个问题，就是我们要使用排他锁来进行分布式锁的lock，那么一个排他锁长时间不提交，就会占用数据库连接。一旦类似的连接变得多了，就可能把数据库连接池撑爆

1.3、总结

总结一下使用数据库来实现分布式锁的方式，这两种方式都是依赖数据库的一张表，一种是通过表中的记录的存在情况确定当前是否有锁存在，另外一种是通过数据库的排他锁来实现分布式锁。

数据库实现分布式锁的优点

直接借助数据库，容易理解。

数据库实现分布式锁的缺点

会有各种各样的问题，在解决问题的过程中会使整个方案变得越来越复杂。

操作数据库需要一定的开销，性能问题需要考虑。

使用数据库的行级锁并不一定靠谱，尤其是当我们的锁表并不大的时候。

2 、zk锁

先了解一下zk
zk是一个Nosql的数据库 有监听机制
zk 与redis类似 都是 no sql
k v结构的数据
创建一个节点命令：
create /deer 1
如果再次执上面那个命令，会执行失败，那么我们就是利用zk这一特性来实现锁的

2.1、下面是zk原生客户端通过临时节点实现一种分布式锁如下：

public abstract class ZookeeperAbstractLock extends AbstractLock {

    private static final String CONNECTSTRING = "127.0.0.1:2181";

    protected ZkClient zkClient = new ZkClient(CONNECTSTRING);

    protected static final String PATH = "/lock";
    protected static final String PATH2 = "/lock2";


}

public  class ZookeeperLock extends ZookeeperAbstractLock {
    private CountDownLatch countDownLatch = null;
    @Override
    public void waitLock() {
        //创建节点删除监听事件
        IZkDataListener iZkDataListener = new IZkDataListener() {
            @Override
            public void handleDataChange(String s, Object o) throws Exception {
            }
            @Override
            public void handleDataDeleted(String s) throws Exception {
                if(countDownLatch != null){
                    countDownLatch.countDown();
                }
            }
        };
        //注册事件
        zkClient.subscribeDataChanges(PATH,iZkDataListener);
        //如果节点存在
        if(zkClient.exists(PATH)){
            countDownLatch = new CountDownLatch(1);
            try{
                countDownLatch.await();
            }catch (Exception e){

            }
        }
        //删除监听
        zkClient.unsubscribeDataChanges(PATH,iZkDataListener);

    }
    @Override
    public void unLock() {
        if(zkClient!=null){
            zkClient.delete(PATH);
            zkClient.close();
            System.out.print("释放资源");
        }
    }
    @Override
    public boolean tryLock() {
        try{
            //创建临时节点
            zkClient.createEphemeral(PATH);
            return true;
        }catch (Exception e){
            return false;
        }
    }
}

运行

public class OrderService {
    private AbstractLock lock = new ZookeeperLock();
    private static  int i = 1;
    public void getNumber(){
        try{
            lock.getLock();
            Date d = new Date();
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            System.out.println("当前时间：" + sdf.format(d));
            String date = sdf.format(d);
            System.out.println(Thread.currentThread().getName()+"生成订单号"+date+"  "+i);
            i = i+1;
        }finally {
            lock.unLock();
        }
    }
    public static void main(String[] args) throws InterruptedException {
        System.out.println("生成唯一订单号");
        for(int i =1;i<=20;i++){
            new Thread(new Runnable() {
                @Override
                public void run() {
                    new OrderService().getNumber();
                }
            }).start();
        }
        Thread.sleep(10000);
    }
}

zk分布锁问题：
会出现死锁问题：通过临时节点可以解决死锁问题。
临时节点特性：在创建节点后，如果程序突中断，那么节点会被自动删除，就不会出现死锁情况。
zk共4种节点类型
1、持久 不会被删除 可以有子节点
2、临时 运行一半，客户端和服务器断开连接 那么节点会被自动删除 不能有子节点
3、临时带序号
4、持久带序号

2.2 基于Curator这个开源框架来实现zk分布式锁

基于Curator这个开源框架来实现zk分布式锁，实际上就是利用临时带序号节点实现的
可查看另一篇文章：5-zk实战，zk应用

2.3、带序号临时节点实现流程图

在这里插入图片描述

3、基于缓存锁 reids

基于缓存锁redis目前也有开源框架redisson，可设置锁过期时间 防止死锁，可watch dog机制实现锁续期，可重入等。具体实现可以查看我的另一篇文章：官方redis实现分布式锁算法-RedLock

三、三种方案的比较

上面几种方式，哪种方式都无法做到完美。就像CAP一样，在复杂性、可靠性、性能等方面无法同时满足，所以，根据不同的应用场景选择最适合自己的才是王道。

从理解的难易程度角度（从低到高）

数据库 > 缓存 > Zookeeper

从实现的复杂性角度（从低到高）

Zookeeper >= 缓存 > 数据库

从性能角度（从高到低）

缓存 > Zookeeper >= 数据库

从可靠性角度（从高到低）

Zookeeper > 缓存 > 数据库

redis
redis简单使用
存1T数据怎么存？
用集群
配置一个读写分离？ slave of
redis主节点有几个子节点 用什么命令： info replication
哨兵 RESP redis底层通信协议
resp手写一个jedis分表分库 手动一个读写分离
redis重启后，数据会丢失吗？ 持久化 2种机制：RDB AOF 2种

redis怎么实现分布锁
setnx 命令
redis怎么实现购物车？ hash
redis怎么实现优惠券功能？ 30过期，发布订阅监听机制，监听失效后 修改数据库中状态

数据库
mysql优化
建表语句 一些索引
写一些sql语句，这些sql是否高效 ，是否用到索引？
index: namd age pos
select * from staffs where name = 1; 1是int ,会有隐式转换，所以索引失效
没有指定列不会用到索引
explain
sql 语句 查看执行计划 ，查看key是否有值 ，有值用到索引，没值没用到索引
select * from staffs where age = 1; 没有用到索引
最佳左前缀原则：

ccddsdsdfsdf
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
使用MySQL实现一个分布式锁
09-08
在分布式系统中，分布锁是一个最基础的工具类。这篇文章主要介绍了用MySQL实现一个分布式锁，本文通过实例代码相结合给大家介绍的非常详细，具有一定的参考借鉴价值,需要的朋友可以参考下
【180414】分布式锁（redis/mysql）
weixin_33778778的博客
04-14 599
单台机器所能承载的量是有限的，用户的量级上万，基本上服务都会做分布式集群部署。很多时候，会遇到对同一资源的方法。这时候就需要锁，如果是单机版的，可以利用java等语言自带的并发同步处理。如果是多台机器部署就得要有个中间代理人来做分布式锁了。 常用的分布式锁的实现有三种方式。 基于redis实现（利用redis的原子性操作setnx来实现） 基于mysql实现（利用mysql的innodb的行锁来...
mysql-分布式锁
以笔为刀的博客
01-25 2657
分布式锁 当我们的微服务连接到一个数据库的时候，可以使用mysql的 select for update 来作为分布式锁使用。 pictureMapper.findLock(); select id from table_lock where id = 'lock' for update 由于我们查询的时候 默认会自动提交，即autoCommit为true。所以有2中方式可以解决。 方式1: 给当前的事务添加@Transactional注解 方式2: 设置提交方式为非自动提交，让我们
基于Mysql实现分布式锁
liuxing201122013的专栏
11-23 167
一.分布式锁要解决的问题 可以保证在分布式部署的应用集群中，同一个方法在同一时间只能被一台机器上的一个线程执行。 这把锁要是一把可重入锁（避免死锁） 这把锁最好是一把阻塞锁（根据业务需求考虑要不要这条） 这把锁最好是一把公平锁（根据业务需求考虑要不要这条） 有高可用的获取锁和释放锁功能 获取锁和释放锁的性能要好 二.基于数据库实现原理 1.新建锁表记录 CREATE TABLE `methodLock` ( `id` int(11) NOT NULL AUTO_INCREMEN
分布式锁-数据库mysql解决方案
苍煜
05-22 638
文章目录1:分布式锁的概念1：概念2：锁/分布式锁/事务区别2：本文使用的案例场景1：需求2：controller层代码3:锁控制层代码（使用synchronized 不成功）4：调用的订单业务代码3：数据库mysql方案1：原理2：musql锁工具类3：业务使用代码4:优缺点 1:分布式锁的概念 1：概念 分布式锁（多服务共享锁） 在分布式的部署环境下，通过锁机制来让多客户端互斥的对共享资源进行访问 控制分布式系统不同进程共同访问共享资源的一种锁的实现。如果不同的系统或同一个系统的不同主机之间共享了某个临
Spring、Java、redis、zk、MySQL等面试题总结
最新发布
05-02
4. 分布式锁：Redis提供了分布式锁实现，如SETNX命令配合超时机制实现简单锁。 5. 持久化：RDB快照和AOF日志两种方式保证数据不丢失。 【Zookeeper面试知识点】 1. Zookeeper概述：Zookeeper是一个分布式的协调...
MySQL借助DB实现分布式锁思路详解
01-21
Redis，ZK对分布式锁提供了很好的支持，基本上开箱即用，然而这些组件本身要高可用，系统也需要强依赖这些组件，额外增加了不少成本。DB对于系统来说本身就默认为高可用组件，针对一些低频的业务使用DB实现分布式锁...
dubbo-d-monitor：dubbo Monitor基于dubbo2.5.3开发的监控平台，兼容了dubbo-admin的特性，有redis，mysql两个版本
02-20
monitor-redis -redis版本（维护终止到2016-06-03，后续暂时不维护） 界面效果图： 一，特性： 修复dubbo-admin的错误：本地应用程序启动停止后，若其相同的应用程序名称服务其他版本号，此本地应用程序的版本号不会...
awesome-programming-resources:收集优秀的Java编程资源，涵盖：Java求职面试，书籍，计算机网络，操作系统，架构，算法，前端开发，Redis，Mysql，Nginx，ZK，MQ等
03-18
涵盖：Java求职面试，书籍，计算机网络，操作系统，架构，算法，前端开发，Redis，Mysql，Nginx，ZK，MQ，深度学习等。如果有推荐的教程或资源，欢迎补充。随着时间的推移，知识点难免有出入和错误，欢迎各位提Java ...
JAVA基础环境搭建jdk、redis、mysql、mycat、zookeeper、nginx搭建
05-11
本文将详细介绍如何在Java平台上搭建一套包括JDK、Redis、MySQL、MyCat、Zookeeper和Nginx的基础环境，使得初学者也能轻松上手。 首先，我们从JDK开始。JDK（Java Development Kit）是Java开发的核心组件，提供了...
NoSql之Redis系列四: Redis实现分布式锁
wau_hua的博客
01-03 326
[OTC](NoSql之Redis系列四: Redis实现分布式锁) 前言 分布式锁的实现方式很多, 可以使用 数据库乐观锁, 可以适用 Zookeeper, 可以使用Redis, 本文总结一下Redis的分布式锁的常用方式. Redis分布式锁的特点 安全: 在任一时刻, 只有一个客户端持有锁, 同一把锁相互排斥. 保活1: 无死锁, 持有锁的客户端崩溃或者网络断开, 也可以获取新锁 保活2:...
分布式锁的三种实现方式
LoveMyTail的博客
07-19 331
因为在面试过程中这方面被问到过，但是当时自己答得不是特别好，所以在此记录一下，我自己的项目是用的redis分布式锁 以下的笔记借鉴了网上其它几位博主的文章，不过因为有一段时间了，原文链接找不到了，在此先行记下。 分布式锁的实现方式一般有三种 基于数据库的实现方式 基于数据库的实现方式的核心思想是：在数据库中创建一个表，表中包含方法名等字段，并在方法名字段上创建唯一索引，想要执行某个方法，就使用这个方法名向表中插入数据，成功插入则获取锁，执行完成后删除对应的行数据释放锁。 注意：这只是使用基于数据库的一种方法
Redis做数据延期处理管道修改
roomlive1的专栏
04-11 506
redis 数据过期数据删除策略： redis 数据过期具体删除位置:          数据删除位置：在文件 dict.c 文件   static int dictGenericDelete(dict *d, const void *key, int nofree) 函数中；         static int dictGenericDelete(dict *d, con
Redis分布式锁的原理以及如何续期
热门推荐
击水三千里的专栏
03-11 3万+
redis 分布式锁的原理
redis续期_redis分布式锁自动延长过期时间
weixin_42319436的博客
01-12 7360
背景项目组已经有个分布式锁注解(参考前文《记一次分布式锁注解化》)，但是在设置锁过期时间时，需要去预估业务耗时时间，如果锁的过期时间能根据业务运行时间自动调整，那使用的就更方便了。思路思路参考了redisson：保留原先的可自定义设置过期时间，只有在没有设置过期时间(过期时间为默认值0)的情况下，才会启动自动延长。申请锁时，设置一个延长过期时间，定时每隔延长过期时间的三分之一时间就重新设置过期时间...
分布式锁实现（mysql redis zk）
qq_31443653的博客
12-13 337
1 mysql方式 利用insert 和 delete控制 2 redis private static final String LOCK_SUCCESS = &quot;OK&quot;; private static final String SET_IF_NOT_EXIST = &quot;NX&quot;; private static final String SET_WITH_EXPIRE_...
【mysql】基于mysql数据库的分布式锁
老汉健身的博客
11-07 1万+
前言:在前面的zk和redis篇已经多次介绍什么是分布式锁,这里就不再赘述了,分布式锁常见的实现方式主要由三种,一种是基于zookeeper实现,一种是基于redis实现,今天要介绍的就是用的最少,最简单,但不太推荐使用的基于mysql数据库实现的分布式锁...之所以不推荐,主要是因为性能不怎样,而且容易造成死锁,但你要想成为一名"高级"java程序猿,即便它不好用,你也得学,说不定哪天就碰上了,...
Redis_14_三种方式实现分布式锁（MySQL、Zookeeper、Redis）
毛毛的专栏
10-12 960
文章目录一、前言二、分布式锁2.1 为何需要分布式锁2.2 分布式锁五个特点三、Mysql分布式锁3.1 MySQL加锁与解锁3.2 锁超时问题3.3 Mysql分布式锁小结3.4 基于MySQL版本号实现的乐观锁四、ZooKeeper分布式锁4.1 ZK加锁与解锁4.2 特殊的读写锁4.3 锁超时问题4.4 ZK分布式锁小结五、Redis分布式锁5.1 Redis分布式锁简单实现5.1.1 Redis分布式锁本质5.1.2 Redis四个基础命令5.1.3 Redis实现分布式锁的两个命令5.2 Jedi
redis-server redis.conf
03-28
However, I can explain what the command "redis-server redis.conf" does. - "redis-server" is a command that starts the Redis server. - "redis.conf" is the configuration file for Redis. It contains ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值