高阶玩家需要掌握的

说说自己的理解，结合背景、业务、代码谈技术

• 分布式系统

结合自己之前做过的业务系统，有这样一个业务场景，也是比较常见的，销售、代理商需要登录系统去给商户开通相应的产品功能；

这个时候比较容易想到的几个业务场景，提单、拆单、工单审批、审批的过程中还需要一系列的RPC、消息交互等等

如果这么多个场景耦合在一起，在一个系统中能实现么？答案是，当然可以，刚毕业那会的项目可能就是都这么做的；

耦合性比较高，业务之间紧密相连，这样做的好处就是事务处理就简单了，本地事务，利用数据库的事务就能帮你解决你会遇到的所有事务问题；

但是随之而来的就是高风险，万一哪个功能点出现问题，系统就挂了，代码会极其多，量变就会产生质变，一旦有功能的加入、或者老人的离职

这个将会是灾难性的，对于新人的入手也会难上加难，所以凡事都有两面性，结合自身的业务需要去做技术选型，脱离业务谈技术就是耍流氓！

这个时候常见的做法就是把巨无霸拆，拆成多个系统，各个系统之间通过网络通讯来完成交互，就是原来的本地API调用，转变成了跨进程，跨服务器的远程调用；

这样子做一下子清晰明了，但是随之而来的就是系统之间错综复杂的调用，事务的一致性无法都到保证，原来只要维护很少的应用现在一下子多了N个。。

即使有上述很多问题，大家还是愿意这样去做，为啥？个人觉得就是现在有很多成熟的开源框架供人们去使用，接入成本大大降低；

想想看，如果没有这些开源的或者商用的技术服务，你敢去拆，一个服务的调用稳定、容灾、并发等等都是需要我们去考虑的等等，就需要大量的中间件去帮我们去屏蔽这些细节！

那么分布式系统出来了，下面就是随之而来的分布式锁、分布式事务、RPC、消息队列、全局ID等一系列高阶玩家需要去摸索和了解的；

• 分布式锁

 我们平常见的比较多的可能就是lock、sychronized这些都是在一个进程中的多线程实现，一旦我们集群了这种加锁的方式就会失效，因为他不能跨JVM，

这个时候我们就需要借助第三方的东西帮我们实现功能

目前主流的有三种，从实现的复杂度上来看，从上往下难度依次增加：

基于数据库实现

基于Redis实现

基于ZooKeeper实现

无论哪种方式，其实都不完美，依旧要根据咱们业务的实际场景来选择。

我们先来看一下如何基于「乐观锁」来实现：

乐观锁就是认为我在执行的时候乐观的以为其他人都不会执行，只有我在执行这更新操作；

乐观锁机制其实就是在数据库表中引入一个版本号（version）字段来实现的。

　　当我们要从数据库中读取数据的时候，同时把这个version字段也读出来，如果要对读出来的数据进行更新后写回数据库，则需要将version加1，同时将新的数据与新的version更新到数据表中，

且必须在更新的时候同时检查目前数据库里version值是不是之前的那个version，如果是，则正常更新。如果不是，则更新失败，说明在这个过程中有其它的进程去更新过数据了。

 

下面找图举例，

 

如图，假设同一个账户，用户A和用户B都要去进行取款操作，账户的原始余额是2000，用户A要去取1500，用户B要去取1000，

如果没有锁机制的话，在并发的情况下，可能会出现余额同时被扣1500和1000，导致最终余额的不正确甚至是负数。

但如果这里用到乐观锁机制，当两个用户去数据库中读取余额的时候，除了读取到2000余额以外，还读取了当前的版本号version=1，

等用户A或用户B去修改数据库余额的时候，无论谁先操作，都会将版本号加1，即version=2，

那么另外一个用户去更新的时候就发现版本号不对，已经变成2了，不是当初读出来时候的1，那么本次更新失败，就得重新去读取最新的数据库余额。

 

通过上面这个例子可以看出来，使用「乐观锁」机制，必须得满足：

 

（1）锁服务要有递增的版本号version

（2）每次更新数据的时候都必须先判断版本号对不对，然后再写入新的版本号

 

我们再来看一下如何基于「悲观锁」来实现：

悲观锁就是我在执行的时候，别人也会去执行，所以我必须把他锁起来，我再操作，不然我不做更新；

悲观锁也叫作排它锁，在Mysql中是基于 for update 来实现加锁的，例如：

 

//锁定的方法-伪代码

public boolean lock(){

    connection.setAutoCommit(false)

   for(){

　　result =select * from user where id = 100 for update;

　　if(result){

　　　　//结果不为空，

　　　　//则说明获取到了锁

　　　　return true;

　　}

　　//没有获取到锁，继续获取

　　sleep(1000);

　　}

　　return false;

}

//释放锁-伪代码

connection.commit();

上面的示例中，user表中，id是主键，通过 for update 操作，数据库在查询的时候就会给这条记录加上排它锁。

（需要注意的是，在InnoDB中只有字段加了索引的，才会是行级锁，否者是表级锁，所以这个id字段要加索引）

当这条记录加上排它锁之后，其它线程是无法操作这条记录的。

那么，这样的话，我们就可以认为获得了排它锁的这个线程是拥有了分布式锁，然后就可以执行我们想要做的业务逻辑，当逻辑完成之后，再调用上述释放锁的语句即可。

给大家看下如何去模拟这个排他锁，直接上截图，有图有真相；Mysql常用的客户端一般都是navicat；　　

比如我们没有上锁，select * from t_shark_user t WHERE t.user_name='1111'(这种操作天生幂等），无论谁去查都OK，但是如果你加了 for update

变成select * from t_shark_user t WHERE t.user_name='1111' for update;这个就会有好玩的情境出现了；

首先，执行下面的命令看下你的自动提交时打开还是关闭的，默认是打开的，就是你每执行一个SQL，mysql会自动帮你commit，不需要你手动进行commit；

如果你的是自动提交的，你for update也没用，因为你刚锁完，他就帮你提交了，也就释放锁了；

show variables like 'autocommit';

为了模拟排他锁，执行命令  set autocommit = 0;这个时候Value就会变成OFF;

在其中一个窗口（session）中执行，怎么执行都是OK的，这条数据，因为这个会话已经获取了该条数据的行级锁，

但是新打开一个窗口，就会不一样了，不信继续往下看：一直在等待，当然他会有个超时时间；

 一直没有结果；select * from t_shark_user t WHERE t.user_name='张书' for update;

 但是查询另外一条数据是OK的，

利用redis实现分布式锁：

大家可以参考下面的博主分享的文章   https://www.lovecto.cn/20180814/203.html，亲测可以用；直接上代码

package com.cloudwalk.shark.config.redisson;

import com.cloudwalk.shark.config.inter.impl.RedissonLocker;
import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.io.IOException;


@Configuration
public class RedissonConfig {

    @Value("${mini.redis.host}")
    private String host;
    @Value("${mini.redis.port}")
    private String port;
    @Value("${mini.redis.passwd}")
    private String password;

    /**
     * RedissonClient,单机模式
     * @return
     * @throws IOException
     */
    @Bean(destroyMethod = "shutdown")
    public RedissonClient redisson() throws IOException {
        Config config = new Config();
        config.useSingleServer().setAddress("redis://" + host + ":" + port).setPassword(password);
        return Redisson.create(config);
    }

    @Bean
    public RedissonLocker redissonLocker(RedissonClient redissonClient){
        RedissonLocker locker = new RedissonLocker(redissonClient);
        //设置LockUtil的锁处理对象
        LockUtil.setLocker(locker);
        return locker;
    }
}

package com.cloudwalk.shark.config.redisson;

import com.cloudwalk.shark.config.inter.Locker;

import java.util.concurrent.TimeUnit;


/**
 * redis分布式锁工具类
 *
 */
public final class LockUtil {

    private static Locker locker;

    /**
     * 设置工具类使用的locker
     * @param locker
     */
    public static void setLocker(Locker locker) {
        LockUtil.locker = locker;
    }

    /**
     * 获取锁
     * @param lockKey
     */
    public static void lock(String lockKey) {
        locker.lock(lockKey);
    }

    /**
     * 释放锁
     * @param lockKey
     */
    public static void unlock(String lockKey) {
        locker.unlock(lockKey);
    }

    /**
     * 获取锁，超时释放
     * @param lockKey
     * @param timeout
     */
    public static void lock(String lockKey, int timeout) {
        locker.lock(lockKey, timeout);
    }

    /**
     * 获取锁，超时释放，指定时间单位
     * @param lockKey
     * @param unit
     * @param timeout
     */
    public static void lock(String lockKey, TimeUnit unit, int timeout) {
        locker.lock(lockKey, unit, timeout);
    }

    /**
     * 尝试获取锁，获取到立即返回true,获取失败立即返回false
     * @param lockKey
     * @return
     */
    public static boolean tryLock(String lockKey) {
        return locker.tryLock(lockKey);
    }

    /**
     * 尝试获取锁，在给定的waitTime时间内尝试，获取到返回true,获取失败返回false,获取到后再给定的leaseTime时间超时释放
     * @param lockKey
     * @param waitTime
     * @param leaseTime
     * @param unit
     * @return
     * @throws InterruptedException
     */
    public static boolean tryLock(String lockKey, long waitTime, long leaseTime,
                                  TimeUnit unit) throws InterruptedException {
        return locker.tryLock(lockKey, waitTime, leaseTime, unit);
    }

    /**
     * 锁释放被任意一个线程持有
     * @param lockKey
     * @return
     */
    public static boolean isLocked(String lockKey) {
        return locker.isLocked(lockKey);
    }
}

package com.cloudwalk.shark.controller;

import com.cloudwalk.shark.config.redisson.LockUtil;
import com.cloudwalk.shark.model.User;
import com.cloudwalk.shark.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.concurrent.TimeUnit;

@Controller
@RequestMapping(value = "/lock", produces = {MediaType.APPLICATION_JSON_UTF8_VALUE})
public class SharkDBLockController {
    @Autowired
    private UserService userService;
    @PostMapping("/db/{userName}")
    @ResponseBody
    public void updateUserScore(@PathVariable("userName") String userName) throws InterruptedException {
        if(LockUtil.tryLock("1", 1,5,TimeUnit.SECONDS) ){
            System.out.println("接收到请求"+userName);
            User user = userService.findUserByName(userName);
            Thread.sleep(2000);
            user.setScore(user.getScore() + 1);
            userService.updateUser(user);
        }else{
            System.out.println("指定时间内没有获取到相应的锁！");
        }
    }
}

通过调节，waitTime，以及leaseTime可以看到效果；

/**
 * 尝试获取锁，在给定的waitTime时间内尝试，获取到返回true,获取失败返回false,获取到后再给定的leaseTime时间超时释放
 * @param lockKey
 * @param waitTime
 * @param leaseTime
 * @param unit
 * @return
 * @throws InterruptedException
 */
public static boolean tryLock(String lockKey, long waitTime, long leaseTime,
                              TimeUnit unit) throws InterruptedException {
    return locker.tryLock(lockKey, waitTime, leaseTime, unit);
}

分布式事务

分布式锁

消息队列

RPC

全局唯一ID生成策略