支撑百万并发的数据库架构如何设计？

时间 2019-12-13

标签支撑百万并发数据库架构如何设计栏目 SQL 繁體版

原文原文链接

前言

做为一个全球人数最多的国家，一个再怎么凄惨的行业，都能找出不少的人为之付出。而在这个互联网的时代，IT公司绝对比牛毛还多不少。可是大多数都是创业公司，长期存活的真的很少。大多数的IT项目在注册量从0-100万，日活跃1-5万，说实话就这种系统随便找一个有几年工做经验的高级工程师，而后带几个年轻工程师，随便干干均可以作出来。
由于这样的系统，实际上主要就是在前期快速的进行业务功能的开发，搞一个单块系统部署在一台服务器上，而后链接一个数据库就能够了。接着你们就是不停的在一个工程里填充进去各类业务代码，尽快把公司的业务支撑起来。html

        可是若是真的发展的还能够，可能就会遇到以下问题：
        在运行的过程当中系统访问数据库的性能愈来愈差，单表数据量愈来愈大，一些复杂查询 SQL直接拖垮！
        这种时候就不得不考虑的解决方案：缓存，负载均衡，项目分块（微服务）；数据库：读写分离，分库分表等技术java

若是说此时你仍是一台数据库服务器在支撑每秒上万的请求，负责任的告诉你，每次高峰期会出现下述问题：git

数据库服务器的磁盘 IO、网络带宽、CPU 负载、内存消耗，都会达到很是高的状况，数据库所在服务器的总体负载会很是重，甚至都快不堪重负了。
高峰期时，原本你单表数据量就很大，SQL 性能就不太好，这时加上你的数据库服务器负载过高致使性能降低，就会发现你的 SQL 性能更差了。
最明显的一个感受，就是你的系统在高峰期各个功能都运行的很慢，用户体验不好，点一个按钮可能要几十秒才出来结果。
若是你运气不太好，数据库服务器的配置不是特别的高的话，弄很差你还会经历数据库宕机的状况，由于负载过高对数据库压力太大了。

那么百万并发的数据库架构如何设计呢？多数都是分库分表加主从吧？算法

分库分表：说白了就是大量分表来保证海量数据下的查询性能。数据库

其实大多数公司的瓶颈都在数据库，其实若是把上面的解决方案，都实现了，基本上就没的什么问题了，举例：
        若是订单一年有 1 亿条数据，能够把订单表一共拆分为 1024 张表，分散在5个库中，这样 1 亿数据量的话，分散到每一个表里也就才 10 万量级的数据量，而后这上千张表分散在 5 台数据库里就能够了。
        在写入数据的时候，须要作两次路由，先对订单 id hash 后对数据库的数量取模，能够路由到一台数据库上，而后再对那台数据库上的表数量取模，就能够路由到数据库上的一个表里了。
        经过这个步骤，就可让每一个表里的数据量很是小，每一年 1 亿数据增加，可是到每一个表里才 10 万条数据增加，这个系统运行 10 年，每一个表里可能才百万级的数据量。缓存

主从：读写分离服务器

这个时候总体效果已经挺不错了，大量分表的策略保证可能将来 10 年，每一个表的数据量都不会太大，这能够保证单表内的 SQL 执行效率和性能。网络

而后多台数据库的拆分方式，能够保证每台数据库服务器承载一部分的读写请求，下降每台服务器的负载。多线程

可是此时还有一个问题，假如说每台数据库服务器承载每秒 2000 的请求，而后其中 400 请求是写入，1600 请求是查询。架构

也就是说，增删改的 SQL 才占到了 20% 的比例，80% 的请求是查询。此时假如说随着用户量愈来愈大，又变成每台服务器承载 4000 请求了。

那么其中 800 请求是写入，3200 请求是查询，若是说你按照目前的状况来扩容，就须要增长一台数据库服务器。

可是此时可能就会涉及到表的迁移，由于须要迁移一部分表到新的数据库服务器上去，是否是很麻烦？

其实彻底不必，数据库通常都支持读写分离，也就是作主从架构。

写入的时候写入主数据库服务器，查询的时候读取从数据库服务器，就可让一个表的读写请求分开落地到不一样的数据库上去执行。

这样的话，假如写入主库的请求是每秒 400，查询从库的请求是每秒 1600。

架构大体以下：

写入主库的时候，会自动同步数据到从库上去，保证主库和从库数据一致。

而后查询的时候都是走从库去查询的，这就经过数据库的主从架构实现了读写分离的效果了。

如今的好处就是，假如说如今主库写请求增长到 800，这个无所谓，不须要扩容。而后从库的读请求增长到了 3200，须要扩容了。

这时，你直接给主库再挂载一个新的从库就能够了，两个从库，每一个从库支撑 1600 的读请求，不须要由于读请求增加来扩容主库。

实际上线上生产你会发现，读请求的增加速度远远高于写请求，因此读写分离以后，大部分时候就是扩容从库支撑更高的读请求就能够了。

并且另一点，对同一个表，若是你既写入数据（涉及加锁），还从该表查询数据，可能会牵扯到锁冲突等问题，不管是写性能仍是读性能，都会有影响。

因此一旦读写分离以后，对主库的表就仅仅是写入，没任何查询会影响他，对从库的表就仅仅是查询。

全局惟一ID

在分库分表以后你必然要面对的一个问题，就是 id 咋生成？由于要是一个表分红多个表以后，每一个表的 id 都是从 1 开始累加自增加，那确定不对啊。

举个例子，你的订单表拆分为了 1024 张订单表，每一个表的 id 都从 1 开始累加，这个确定有问题了！

你的系统就没办法根据表主键来查询订单了，好比 id = 50 这个订单，在每一个表里都有！

因此此时就须要分布式架构下的全局惟一 id 生成的方案了，在分库分表以后，对于插入数据库中的核心 id，不能直接简单使用表自增 id，要全局生成惟一 id，而后插入各个表中，保证每一个表内的某个 id，全局惟一。

好比说订单表虽然拆分为了 1024 张表，可是 id = 50 这个订单，只会存在于一个表里。

那么如何实现全局惟一 id 呢？有如下几种方案：

方案一：独立数据库自增 id

这个方案就是说你的系统每次要生成一个 id，都是往一个独立库的一个独立表里插入一条没什么业务含义的数据，而后获取一个数据库自增的一个 id。拿到这个 id 以后再往对应的分库分表里去写入。

好比说你有一个 auto_id 库，里面就一个表，叫作 auto_id 表，有一个 id 是自增加的。

那么你每次要获取一个全局惟一 id，直接往这个表里插入一条记录，获取一个全局惟一 id 便可，而后这个全局惟一 id 就能够插入订单的分库分表中。

这个方案的好处就是方便简单，谁都会用。缺点就是单库生成自增 id，要是高并发的话，就会有瓶颈的，由于 auto_id 库要是承载个每秒几万并发，确定是不现实的了。

方案二：UUID

这个每一个人都应该知道吧，就是用 UUID 生成一个全局惟一的 id。

好处就是每一个系统本地生成，不要基于数据库来了。很差之处就是，UUID 太长了，做为主键性能太差了，不适合用于主键。

若是你是要随机生成个什么文件名了，编号之类的，你能够用 UUID，可是做为主键是不能用 UUID 的。

方案三：获取系统当前时间

这个方案的意思就是获取当前时间做为全局惟一的 id。可是问题是，并发很高的时候，好比一秒并发几千，会有重复的状况，这个确定是不合适的。

通常若是用这个方案，是将当前时间跟不少其余的业务字段拼接起来，做为一个 id，若是业务上你以为能够接受，那么也是能够的。

你能够将别的业务字段值跟当前时间拼接起来，组成一个全局惟一的编号，好比说订单编号：时间戳 + 用户 id + 业务含义编码。

方案四：SnowFlake 算法的思想分析

SnowFlake 算法，是 Twitter 开源的分布式 id 生成算法。其核心思想就是：使用一个 64 bit 的 long 型的数字做为全局惟一 id。这 64 个 bit 中，其中 1 个 bit 是不用的，而后用其中的 41 bit 做为毫秒数，用 10 bit 做为工做机器 id，12 bit 做为序列号。

给你们举个例子吧，好比下面那个 64 bit 的 long 型数字：

第一个部分，是 1 个 bit：0，这个是无心义的。
第二个部分是 41 个 bit：表示的是时间戳。
第三个部分是 5 个 bit：表示的是机房 id，10001。
第四个部分是 5 个 bit：表示的是机器 id，1 1001。
第五个部分是 12 个 bit：表示的序号，就是某个机房某台机器上这一毫秒内同时生成的 id 的序号，0000 00000000。

①1 bit：是不用的，为啥呢？

由于二进制里第一个 bit 为若是是 1，那么都是负数，可是咱们生成的 id 都是正数，因此第一个 bit 统一都是 0。

②41 bit：表示的是时间戳，单位是毫秒。

41 bit 能够表示的数字多达 2^41 - 1，也就是能够标识 2 ^ 41 - 1 个毫秒值，换算成年就是表示 69 年的时间。

③10 bit：记录工做机器 id，表明的是这个服务最多能够部署在 2^10 台机器上，也就是 1024 台机器。

可是 10 bit 里 5 个 bit 表明机房 id，5 个 bit 表明机器 id。意思就是最多表明 2 ^ 5 个机房（32 个机房），每一个机房里能够表明 2 ^ 5 个机器（32 台机器）。

④12 bit：这个是用来记录同一个毫秒内产生的不一样 id。

12 bit 能够表明的最大正整数是 2 ^ 12 - 1 = 4096，也就是说能够用这个 12 bit 表明的数字来区分同一个毫秒内的 4096 个不一样的 id。简单来讲，你的某个服务假设要生成一个全局惟一 id，那么就能够发送一个请求给部署了 SnowFlake 算法的系统，由这个 SnowFlake 算法系统来生成惟一 id。

这个 SnowFlake 算法系统首先确定是知道本身所在的机房和机器的，好比机房 id = 17，机器 id = 12。

接着 SnowFlake 算法系统接收到这个请求以后，首先就会用二进制位运算的方式生成一个 64 bit 的 long 型 id，64 个 bit 中的第一个 bit 是无心义的。

接着 41 个 bit，就能够用当前时间戳（单位到毫秒），而后接着 5 个 bit 设置上这个机房 id，还有 5 个 bit 设置上机器 id。

最后再判断一下，当前这台机房的这台机器上这一毫秒内，这是第几个请求，给此次生成 id 的请求累加一个序号，做为最后的 12 个 bit。

最终一个 64 个 bit 的 id 就出来了，相似于：

这个算法能够保证说，一个机房的一台机器上，在同一毫秒内，生成了一个惟一的 id。可能一个毫秒内会生成多个 id，可是有最后 12 个 bit 的序号来区分开来。

下面咱们简单看看这个 SnowFlake 算法的一个代码实现，这就是个示例，你们若是理解了这个意思以后，之后能够本身尝试改造这个算法。

总之就是用一个 64 bit 的数字中各个 bit 位来设置不一样的标志位，区分每个 id。

SnowFlake 算法JAVA版（含测试方法）：

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.CountDownLatch;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import lombok.ToString;

/**   
* Copyright: Copyright (c) 2019 
* 
* @ClassName: IdWorker.java
* @Description: <p>SnowFlake 算法，是 Twitter 开源的分布式 id 生成算法。
* 					其核心思想就是：使用一个 64 bit 的 long 型的数字做为全局惟一 id。
* 					这 64 个 bit 中，其中 1 个 bit 是不用的，而后用其中的 41 bit 做为毫秒数，
* 					用 10 bit 做为工做机器 id，12 bit 做为序列号
*				</p>
* @version: v1.0.0
* @author: BianPeng
* @date: 2019年4月11日 下午3:13:41 
*
* Modification History:
* Date         		Author          Version          Description
*---------------------------------------------------------------*
* 2019年4月11日      		BianPeng        v1.0.0           initialize
*/
@ToString
public class SnowflakeIdFactory {
 
	static Logger log = LoggerFactory.getLogger(SnowflakeIdFactory.class);
	
    private final long twepoch = 1288834974657L;
    private final long workerIdBits = 5L;
    private final long datacenterIdBits = 5L;
    private final long maxWorkerId = -1L ^ (-1L << workerIdBits);
    private final long maxDatacenterId = -1L ^ (-1L << datacenterIdBits);
    private final long sequenceBits = 12L;
    private final long workerIdShift = sequenceBits;
    private final long datacenterIdShift = sequenceBits + workerIdBits;
    private final long timestampLeftShift = sequenceBits + workerIdBits + datacenterIdBits;
    private final long sequenceMask = -1L ^ (-1L << sequenceBits);
 
    private long workerId;
    private long datacenterId;
    private long sequence = 0L;
    private long lastTimestamp = -1L;
 
 
 
    public SnowflakeIdFactory(long workerId, long datacenterId) {
        if (workerId > maxWorkerId || workerId < 0) {
            throw new IllegalArgumentException(String.format("worker Id can't be greater than %d or less than 0", maxWorkerId));
        }
        if (datacenterId > maxDatacenterId || datacenterId < 0) {
            throw new IllegalArgumentException(String.format("datacenter Id can't be greater than %d or less than 0", maxDatacenterId));
        }
        this.workerId = workerId;
        this.datacenterId = datacenterId;
    }
 
    public synchronized long nextId() {
        long timestamp = timeGen();
        if (timestamp < lastTimestamp) {
            //服务器时钟被调整了,ID生成器中止服务.
            throw new RuntimeException(String.format("Clock moved backwards.  Refusing to generate id for %d milliseconds", lastTimestamp - timestamp));
        }
        if (lastTimestamp == timestamp) {
            sequence = (sequence + 1) & sequenceMask;
            if (sequence == 0) {
                timestamp = tilNextMillis(lastTimestamp);
            }
        } else {
            sequence = 0L;
        }
 
        lastTimestamp = timestamp;
        return ((timestamp - twepoch) << timestampLeftShift) | (datacenterId << datacenterIdShift) | (workerId << workerIdShift) | sequence;
    }
 
    protected long tilNextMillis(long lastTimestamp) {
        long timestamp = timeGen();
        while (timestamp <= lastTimestamp) {
            timestamp = timeGen();
        }
        return timestamp;
    }
 
    protected long timeGen() {
        return System.currentTimeMillis();
    }
 
    public static void testProductIdByMoreThread(int dataCenterId, int workerId, int n) throws InterruptedException {
        List<Thread> tlist = new ArrayList<>();
        Set<Long> setAll = new HashSet<>();
        CountDownLatch cdLatch = new CountDownLatch(10);
        long start = System.currentTimeMillis();
        int threadNo = dataCenterId;
        Map<String,SnowflakeIdFactory> idFactories = new HashMap<>();
        for(int i=0;i<10;i++){
            //用线程名称作map key.
            idFactories.put("snowflake"+i,new SnowflakeIdFactory(workerId, threadNo++));
        }
        for(int i=0;i<10;i++){
            Thread temp =new Thread(new Runnable() {
                @Override
                public void run() {
                    Set<Long> setId = new HashSet<>();
                    SnowflakeIdFactory idWorker = idFactories.get(Thread.currentThread().getName());
                    for(int j=0;j<n;j++){
                        setId.add(idWorker.nextId());
                    }
                    synchronized (setAll){
                        setAll.addAll(setId);
                        log.info("{}生产了{}个id,并成功加入到setAll中.",Thread.currentThread().getName(),n);
                    }
                    cdLatch.countDown();
                }
            },"snowflake"+i);
            tlist.add(temp);
        }
        for(int j=0;j<10;j++){
            tlist.get(j).start();
        }
        cdLatch.await();
 
        long end1 = System.currentTimeMillis() - start;
 
        log.info("共耗时:{}毫秒,预期应该生产{}个id, 实际合并总计生成ID个数:{}",end1,10*n,setAll.size());
 
    }
 
    public static void testProductId(int dataCenterId, int workerId, int n){
        SnowflakeIdFactory idWorker = new SnowflakeIdFactory(workerId, dataCenterId);
        SnowflakeIdFactory idWorker2 = new SnowflakeIdFactory(workerId+1, dataCenterId);
        Set<Long> setOne = new HashSet<>();
        Set<Long> setTow = new HashSet<>();
        long start = System.currentTimeMillis();
        for (int i = 0; i < n; i++) {
            setOne.add(idWorker.nextId());//加入set
        }
        long end1 = System.currentTimeMillis() - start;
        log.info("第一批ID预计生成{}个,实际生成{}个<<<<*>>>>共耗时:{}",n,setOne.size(),end1);
 
        for (int i = 0; i < n; i++) {
            setTow.add(idWorker2.nextId());//加入set
        }
        long end2 = System.currentTimeMillis() - start;
        log.info("第二批ID预计生成{}个,实际生成{}个<<<<*>>>>共耗时:{}",n,setTow.size(),end2);
 
        setOne.addAll(setTow);
        log.info("合并总计生成ID个数:{}",setOne.size());
 
    }
 
    public static void testPerSecondProductIdNums(){
        SnowflakeIdFactory idWorker = new SnowflakeIdFactory(1, 2);
        long start = System.currentTimeMillis();
        int count = 0;
        for (int i = 0; System.currentTimeMillis()-start<1000; i++,count=i) {
            /**  测试方法一: 此用法纯粹的生产ID,每秒生产ID个数为400w+ */
        	//idWorker.nextId();
            /**  测试方法二: 在log中打印,同时获取ID,此用法生产ID的能力受限于log.error()的吞吐能力.
             * 每秒徘徊在10万左右. */
        	log.info(""+idWorker.nextId());
        }
        long end = System.currentTimeMillis()-start;
        System.out.println(end);
        System.out.println(count);
    }
 
    public static void main(String[] args) {
        /** case1: 测试每秒生产id个数?
         *   结论: 每秒生产id个数400w+ 
         */
        //testPerSecondProductIdNums();
 
        /** case2: 单线程-测试多个生产者同时生产N个id,验证id是否有重复?
         *   结论: 验证经过,没有重复. 
         */
        //testProductId(1,2,10000);//验证经过!
        //testProductId(1,2,20000);//验证经过!
 
        /** case3: 多线程-测试多个生产者同时生产N个id, 所有id在全局范围内是否会重复?
         *   结论: 验证经过,没有重复.
         */
        try {
            testProductIdByMoreThread(1,2,100000);//单机测试此场景,性能损失至少折半!
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
 
    }
}

这个算法也叫雪花算法我使用的类源码：https://gitee.com/flying-cattle/earn_knife/blob/master/item-common/src/main/java/com/item/util/SnowflakeIdWorker.java

其次在推荐一种算法：国美最近开源的分布式ID：https://tech.meituan.com/2019/03/07/open-source-project-leaf.html

项目是一个递进的过程，优先考虑缓存，其次读写分离，再分表分库。固然这只是我的想法，各位伙伴仍是根据本身的项目和业务来综合考虑实行方案。