java中mysql分布式锁的是什么

今天就跟大家聊聊有关java中MySQL分布式锁的是什么,可能很多人都不太了解,为了让大家更加了解,小编给大家总结了以下内容,希望大家根据这篇文章可以有所收获。

10年积累的做网站、成都网站设计经验,可以快速应对客户对网站的新想法和需求。提供各种问题对应的解决方案。让选择我们的客户得到更好、更有力的网络服务。我虽然不认识你,你也不认识我。但先做网站设计后付款的网站建设流程,更有林周免费网站建设让你可以放心的选择与我们合作。

问题

(1)什么是分布式锁?

(2)为什么需要分布式锁?

(3)mysql如何实现分布式锁?

(4)mysql分布式锁的优点和缺点?

简介

随着并发量的不断增加,单机的服务迟早要向多节点或者微服务进化,这时候原来单机模式下使用的synchronized或者ReentrantLock将不再适用,我们迫切地需要一种分布式环境下保证线程安全的解决方案,今天我们一起来学习一下mysql分布式锁如何实现分布式线程安全。

基础知识

mysql中提供了两个函数——get_lock('key', timeout)release_lock('key')——来实现分布式锁,可以根据key来加锁,这是一个字符串,可以设置超时时间(单位:秒),当调用release_lock('key')或者客户端断线的时候释放锁。

它们的使用方法如下:

mysql> select get_lock('user_1', 10);
    -> 1
mysql> select release_lock('user_1');
    -> 1

get_lock('user_1', 10)如果10秒之内获取到锁则返回1,否则返回0;

release_lock('user_1')如果该锁是当前客户端持有的则返回1,如果该锁被其它客户端持有着则返回0,如果该锁没有被任何客户端持有则返回null;

多客户端案例

为了便于举例,本文由公从号“彤哥读源码”原创,这里的超时时间全部设置为0,也就是立即返回。

时刻客户端A客户端B
1get_lock('user_1', 0) -> 1-
2-get_lock('user_1', 0) -> 0
3-release_lock('user_1', 0) -> 0
4release_lock('user_1', 0) -> 1-
5release_lock('user_2', 0) -> null-
6-get_lock('user_1', 0) -> 1
7-release_lock('user_1', 0) -> 1

Java实现

为了方便快速实现,这里使用 springboot2.1 + mybatis 实现,并且省略spring的配置,只列举主要的几个类。

定义Locker接口

接口中只有一个方法,入参1为加锁的key,入参2为执行的命令。

public interface Locker {
    void lock(String key, Runnable command);
}

mysql分布式锁实现

mysql的实现中要注意以下两点:

(1)加锁、释放锁必须在同一个session(同一个客户端)中,所以这里不能使用Mapper接口的方式调用,因为Mapper接口有可能会导致不在同一个session。

(2)可重入性是通过ThreadLocal保证的;

@Slf4j
@Component
public class MysqlLocker implements Locker {

    private static final ThreadLocal localSession = new ThreadLocal<>();

    @Autowired
    private SqlSessionFactory sqlSessionFactory;

    @Override
    public void lock(String key, Runnable command) {
        // 加锁、释放锁必须使用同一个session
        SqlSessionWrapper sqlSessionWrapper = localSession.get();
        if (sqlSessionWrapper == null) {
            // 第一次获取锁
            localSession.set(new SqlSessionWrapper(sqlSessionFactory.openSession()));
        }
        try {
            // 本文由公从号“彤哥读源码”原创
            // -1表示没获取到锁一直等待
            if (getLock(key, -1)) {
                command.run();
            }
        } catch (Exception e) {
            log.error("lock error", e);
        } finally {
            releaseLock(key);
        }
    }

    private boolean getLock(String key, long timeout) {
        Map param = new HashMap<>();
        param.put("key", key);
        param.put("timeout", timeout);
        SqlSessionWrapper sqlSessionWrapper = localSession.get();
        Integer result = sqlSessionWrapper.sqlSession.selectOne("LockerMapper.getLock", param);
        if (result != null && result.intValue() == 1) {
            // 获取到了锁,state加1
            sqlSessionWrapper.state++;
            return true;
        }
        return false;
    }

    private boolean releaseLock(String key) {
        SqlSessionWrapper sqlSessionWrapper = localSession.get();
        Integer result = sqlSessionWrapper.sqlSession.selectOne("LockerMapper.releaseLock", key);
        if (result != null && result.intValue() == 1) {
            // 释放锁成功,state减1
            sqlSessionWrapper.state--;
            // 当state减为0的时候说明当前线程获取的锁全部释放了,则关闭session并从ThreadLocal中移除
            if (sqlSessionWrapper.state == 0) {
                sqlSessionWrapper.sqlSession.close();
                localSession.remove();
            }
            return true;
        }
        return false;
    }

    private static class SqlSessionWrapper {
        int state;
        SqlSession sqlSession;

        public SqlSessionWrapper(SqlSession sqlSession) {
            this.state = 0;
            this.sqlSession = sqlSession;
        }
    }
}

LockerMapper.xml

定义get_lock()、release_lock()的语句。





    
        select get_lock(#{key}, #{timeout});
    

    
        select release_lock(#{key})
    

测试类

这里启动1000个线程,每个线程打印一句话并睡眠2秒钟。

@RunWith(SpringRunner.class)
@SpringBootTest(classes = Application.class)
public class MysqlLockerTest {

    @Autowired
    private Locker locker;

    @Test
    public void testMysqlLocker() throws IOException {
        for (int i = 0; i < 1000; i++) {
            // 多节点测试
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            new Thread(()->{
                locker.lock("lock", ()-> {
                    // 可重入性测试
                    locker.lock("lock", ()-> {
                        System.out.println(String.format("time: %d, threadName: %s", System.currentTimeMillis(), Thread.currentThread().getName()));
                        try {
                            Thread.sleep(2000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    });
                });
            }, "Thread-"+i).start();
        }

        System.in.read();
    }
}

运行结果

查看运行结果发现每隔2秒打印一个线程的信息,说明这个锁是有效的,至于分布式环境下面的验证也很简单,起多个MysqlLockerTest实例即可。

time: 1568715905952, threadName: Thread-3
time: 1568715907955, threadName: Thread-4
time: 1568715909966, threadName: Thread-8
time: 1568715911967, threadName: Thread-0
time: 1568715913969, threadName: Thread-1
time: 1568715915972, threadName: Thread-9
time: 1568715917975, threadName: Thread-6
time: 1568715919997, threadName: Thread-5
time: 1568715921999, threadName: Thread-7
time: 1568715924001, threadName: Thread-2

总结

(1)分布式环境下需要使用分布式锁,单机的锁将无法保证线程安全;

(2)mysql分布式锁是基于get_lock('key', timeout)release_lock('key')两个函数实现的;

(3)mysql分布式锁是可重入锁;

彩蛋

使用mysql分布式锁需要注意些什么呢?

答:必须保证多个服务节点使用的是同一个mysql库,本文由公从号“彤哥读源码”原创。

mysql分布式锁具有哪些优点?

答:1)方便快捷,因为基本每个服务都会连接数据库,但是不是每个服务都会使用redis或者zookeeper;

2)如果客户端断线了会自动释放锁,不会造成锁一直被占用;

3)mysql分布式锁是可重入锁,对于旧代码的改造成本低;

mysql分布式锁具有哪些缺点?

答:1)加锁直接打到数据库,增加了数据库的压力;

2)加锁的线程会占用一个session,也就是一个连接数,如果并发量大可能会导致正常执行的sql语句获取不到连接;

3)服务拆分后如果每个服务使用自己的数据库,则不合适;

4)相对于redis或者zookeeper分布式锁,效率相对要低一些;

看完上述内容,你们对java中mysql分布式锁的是什么有进一步的了解吗?如果还想了解更多知识或者相关内容,请关注创新互联行业资讯频道,感谢大家的支持。


本文名称:java中mysql分布式锁的是什么
标题路径:http://pwwzsj.com/article/iidddj.html