数据仓库：Mysql大量数据快速导出

背景

写这篇文章主要是介绍一下我作数据仓库ETL同步的过程当中遇到的一些有意思的内容和提高程序运行效率的过程。

关系型数据库：

　　项目初期：游戏的运营数据比较轻量，相关的运营数据是经过Java后台程序聚合查询关系型数据库MySQL彻底能够应付，系统经过定时任务每日统计相关数据，等待运营人员查询便可。

　　项目中后期：随着开服数量增多，玩家数量愈来愈多，数据库的数据量愈来愈大，运营后台查询效率愈来愈低。对于普通的关系型来讲，如MySQL，当单表存储记录数超过500万条后，数据库查询性能将变得极为缓慢，而每每咱们都不会只作单表查询，还有多表join。这里假若有100个游戏服，每一个服有20张表，而每一个表有500W数据，那么：

　　总数据量 = 100 * 20 * 500W = 10亿  按当时的库表结构，换算成磁盘空间，约为100G左右

个人天呐，如今没有单机的内存能同一时间载入100G的数据

https://www.zhihu.com/question/19719997

　　因此，考虑到这一点，Hive被提出来解决难题!

 

数据仓库

Hive适合作海量数据的数据仓库工具, 由于数据仓库中的数据有这两个特色：最全的历史数据（海量）、相对稳定的；所谓相对稳定，指的是数据仓库不一样于业务系统数据库，数据常常会被更新，数据一旦进入数据仓库，不多会被更新和删除，只会被大量查询。而Hive，也是具有这两个特色

https://my.oschina.net/leejun2005/blog/189035

2、项目架构设计

 在这里先说下初期项目架构的探索，由于数据流向，其实最终就是从MYSQL--------->Hive中，我使用的是Jdbc方式。为何不使用下列工具呢？

• Sqoop, 由于该游戏每一个服有将近80张表，而后又有不少服，之后还会更多，而每一个服的库表数据结构实际上是彻底同样的，只是IP地址不同，使用Sqoop的话，将会须要维护愈来愈多的脚本，再者Sqoop无法处理原始数据中一些带有Hive表定义的行列分隔符
• DataX 阿里开源的数据同步中间件，没作过详细研究

一、全局缓存队列

使用生产者消费者模型，中间使用内存，数据落地成txt

 

 

首先生产者经过Jdbc获取源数据内容，放入固定大小的缓存队列，同时消费者不断的从缓存读取数据，根据不一样的数据类型分别读取出来，并逐条写入相应的txt文件。

速度每秒约8000条。

这样作表面上看起来很是美好，流水式的处理，来一条处理一下，但是发现消费的速度远远赶不上生产的速度，生产出来的数据会堆积在缓存队列里面，假如队列不固定长度的话，这时候还会大量消耗内存，因此为了提高写入的速度，决定采用下一种方案

 

二、每一张表一个缓存队列及writer接口

每张表各自起一个生产者消费者模型，消费者启动时初始化相应的writer接口，架构设计以下：

 

table1的生产者经过Jdbc获取源数据内容，放入table自带的固定大小的缓存队列，同时table1相应的消费者不断的从缓存读取数据，根据不一样的数据类型分别读取出来，并逐条写入相应的txt文件。

速度每秒约2W条。

 这样生产者线程能够并发的进行，经过控制生产者线程的数量，能够大大提升处理的效率, 项目关键代码以下：

1）线程池

/***
 * 
 * 
 * @描述 任务线程池
 */
public class DumpExecuteService {

    private static ExecutorService dumpServerWorkerService; // 游戏服任务
    private static ExecutorService dumpTableWorkerService; // 表数据任务
    private static ExecutorService dumpReaderWorkerService; // 读取数据任务
    private static ExecutorService dumpWriterWorkerService; // 写数据结果任务

    /***
     * 初始化任务线程池
     * @param concurrencyDBCount 并发数量
     */
    public synchronized static void startup(int concurrencyDBCount) {

        if (dumpServerWorkerService != null)
            return;

        if (concurrencyDBCount > 2)
            concurrencyDBCount = 2; // 最多支持两个数据库任务并发执行

        if (concurrencyDBCount < 1)
            concurrencyDBCount = 1;

        dumpServerWorkerService = Executors.newFixedThreadPool(concurrencyDBCount, new NamedThreadFactory(
                "DumpExecuteService.dumpServerWorkerService" + System.currentTimeMillis()));
        dumpTableWorkerService = Executors.newFixedThreadPool(2, new NamedThreadFactory("DumpExecuteService.dumpTableWorkerService"
                + System.currentTimeMillis()));
        dumpWriterWorkerService = Executors.newFixedThreadPool(8, new NamedThreadFactory("DumpExecuteService.dumpWriterWorkerService"
                + System.currentTimeMillis()));
        dumpReaderWorkerService = Executors.newFixedThreadPool(2, new NamedThreadFactory("DumpExecuteService.dumpReaderWorkerService"
                + System.currentTimeMillis()));
    }

    public static Future<Integer> submitDumpServerWorker(DumpServerWorkerLogic worker) {
        return dumpServerWorkerService.submit(worker);
    }

    public static Future<Integer> submitDumpWriteWorker(DumpWriteWorkerLogic worker) {
        return dumpWriterWorkerService.submit(worker);
    }

    public static Future<Integer> submitDumpReadWorker(DumpReadWorkerLogic worker) {
        return dumpReaderWorkerService.submit(worker);
    }

    public static Future<Integer> submitDumpTableWorker(DumpTableWorkerLogic worker) {
        return dumpTableWorkerService.submit(worker);
    }

    /***
     * 关闭线程池
     */
    public synchronized static void shutdown() {

        //执行线程池关闭...
    }
}

说明：该类定义4个线程池，分别用于执行不一样的任务

2）游戏服任务线程池

/**
 * 1) 获取 游戏服log库数据库链接 
   2) 依次处理单张表
 */
public class DumpServerWorkerLogic extends AbstractLogic implements Callable<Integer> {
    private static Logger logger = LoggerFactory.getLogger(DumpServerWorkerLogic.class);

    private final ServerPO server;// 数据库

    private final String startDate;// 开始时间

    private SourceType sourceType;// 数据来源类型

    private Map<String, Integer> resultDBMap;// 表记录计数

    private GameType gameType;

    public DumpServerWorkerLogic(ServerPO server, String startDate, SourceType sourceType, Map<String, Integer> resultDBMap,
            GameType gameType) {
        CheckUtil.checkNotNull("DumpServerWorkerLogic.server", server);
        CheckUtil.checkNotNull("DumpServerWorkerLogic.startDate", startDate);
        CheckUtil.checkNotNull("DumpServerWorkerLogic.sourceType", sourceType);
        CheckUtil.checkNotNull("DumpServerWorkerLogic.resultDBMap", resultDBMap);
        CheckUtil.checkNotNull("DumpServerWorkerLogic.gameType", gameType);

        this.server = server;
        this.startDate = startDate;
        this.sourceType = sourceType;
        this.resultDBMap = resultDBMap;
        this.gameType = gameType;
    }

    @Override
    public Integer call() {

        // 获取链接, 并取得该库的全部表
        Connection conn = null;
        try {
            conn = JdbcUtils.getDbConnection(server);
        }
        catch (Exception e) {
            throw new GameRuntimeException(e.getMessage(), e);
        }
        List<String> tableNames = null;
        DumpDbInfoBO dumpDbInfoBO = DumpConfig.getDumpDbInfoBO();

        int totalRecordCount = 0;
        try {
            switch (this.sourceType) {
            case GAME_LOG:
                tableNames = JdbcUtils.getAllTableNames(conn);
                break;
            case INFOCENTER:
                tableNames = dumpDbInfoBO.getIncludeInfoTables();
                tableNames.add("pay_action");
                break;
            case EVENT_LOG:
                tableNames = new ArrayList<String>();
                Date date = DateTimeUtil.string2Date(startDate, "yyyy-MM-dd");
                String sdate = DateTimeUtil.date2String(date, "yyyyMMdd");
                String smonth = DateTimeUtil.date2String(date, "yyyyMM");
                tableNames.add("log_device_startup" + "_" + smonth);
                tableNames.add("log_device" + "_" + sdate);
                break;
            }

            // 遍历table
            for (String tableName : tableNames) {
                // 过滤
                if (dumpDbInfoBO.getExcludeTables().contains(tableName))
                    continue;
                DumpTableWorkerLogic tableTask = new DumpTableWorkerLogic(conn, server, tableName, startDate, resultDBMap,
                        gameType, sourceType);
                Future<Integer> tableFuture = DumpExecuteService.submitDumpTableWorker(tableTask);
                int count = tableFuture.get();
                totalRecordCount += count;
                logger.info(String.format("DumpServerWorkerLogic %s-%s.%s be done", startDate, server.getLogDbName(), tableName));
            }
            return totalRecordCount;
        } catch (Exception e) {
            throw new GameRuntimeException(e, "DumpTableWorkerLogic fail. server={%s}, errorMsg={%s} ",server.getId(), e.getMessage());
        } finally {
            JdbcUtils.closeConnection(conn);
        }

    }

}

 

 3）表处理任务,一个表一个

 

/***
 * 
 * 
 * @描述 建立一个表查询结果写任务 (一个表一个)
 */
public class DumpTableWorkerLogic implements Callable<Integer> {
    private static Logger logger = LoggerFactory.getLogger(DumpTableWorkerLogic.class);

    private final String tableName;
    private final Connection conn;

    private ServerPO server;

    private String startDate;

    private Map<String, Integer> resultDBMap;// 表记录计数

    private GameType gameType;

    private SourceType sourceType;// 数据来源类型

    public DumpTableWorkerLogic(Connection conn, ServerPO server, String tableName, String startDate, Map<String, Integer> resultDBMap,
            GameType gameType, SourceType sourceType) {
        CheckUtil.checkNotNull("DumpTableWorkerLogic.conn", conn);
        CheckUtil.checkNotNull("DumpTableWorkerLogic.tableName", tableName);
        CheckUtil.checkNotNull("DumpTableWorkerLogic.server", server);
        CheckUtil.checkNotNull("DumpTableWorkerLogic.startDate", startDate);
        CheckUtil.checkNotNull("DumpTableWorkerLogic.resultDBMap", resultDBMap);
        CheckUtil.checkNotNull("DumpTableWorkerLogic.gameType", gameType);
        CheckUtil.checkNotNull("DumpServerWorkerLogic.sourceType", sourceType);

        this.conn = conn;
        this.tableName = tableName;
        this.server = server;
        this.startDate = startDate;
        this.resultDBMap = resultDBMap;
        this.gameType = gameType;
        this.sourceType = sourceType;

        logger.info("DumpTableWorkerLogic[{}] Reg", tableName);
    }

    @Override
    public Integer call() {
        logger.info("DumpTableWorkerLogic[{}] Start", tableName);

        // 写检查结果任务
        DumpWriteWorkerLogic writerWorker = new DumpWriteWorkerLogic(server, tableName, startDate, resultDBMap, gameType,
                sourceType);
        Future<Integer> writeFuture = DumpExecuteService.submitDumpWriteWorker(writerWorker);
        logger.info("DumpTableWorkerLogic[{}] writer={}", tableName);

        // 数据查询任务
        DumpReadWorkerLogic readerWorker = new DumpReadWorkerLogic(conn, tableName, writerWorker, startDate);
        DumpExecuteService.submitDumpReadWorker(readerWorker);
        logger.info("DumpTableWorkerLogic[{}] reader={}", tableName);

        try {
            int writeCount = writeFuture.get();
            logger.info("DumpTableWorkerLogic[{}] ---" + startDate + "---" + server.getId() + "---" + tableName + "---导出数据条数---"
                    + writeCount);
            return writeCount;
        }  catch (Exception e) {
            throw new GameRuntimeException(e, "DumpTableWorkerLogic fail. tableName={%s}, errorMsg={%s} ",tableName, e.getMessage());
        }
    }

}

 

 

4）单表读取任务线程

/***
 * mysql读取数据任务
 * 
 */
public class DumpReadWorkerLogic implements Callable<Integer> {

    private static Logger logger = LoggerFactory.getLogger(DumpReadWorkerLogic.class);

    private String tableName;

    private final Connection conn;

    private DumpWriteWorkerLogic writerWorker; // 写结果数据任务

    private String startDate;// 开始导出日期

    private static final int LIMIT = 50000;// 限制sql一次读出条数

    public DumpReadWorkerLogic(Connection conn, String tableName, DumpWriteWorkerLogic writerWorker, String startDate) {
        CheckUtil.checkNotNull("MysqlDataReadWorker.conn", conn);
        CheckUtil.checkNotNull("MysqlDataReadWorker.tableName", tableName);
        CheckUtil.checkNotNull("MysqlDataReadWorker.startDate", startDate);

        this.conn = conn;
        this.tableName = tableName;
        this.writerWorker = writerWorker;
        this.startDate = startDate;

        logger.info("DumpReadWorkerLogic Reg. tableName={}", this.tableName);
    }

    @Override
    public Integer call() {
        try {
            List<Map<String, Object>> result = JdbcUtils.queryForList(conn, "show full fields from " + tableName);

            int index = 0;
            String querySql = "";

            int totalCount = 0;
            while (true) {
                int offset = index * LIMIT;
                querySql = DumpLogic.getTableQuerySql(result, tableName, true, startDate) + " limit " + offset + "," + LIMIT;
                int row = DumpLogic.query(conn, querySql, writerWorker);
                totalCount += row;
                logger.info("tableName=" + tableName + ", offset=" + offset + ", index=" + index + ", row=" + row + ", limit=" + LIMIT);
                if (row < LIMIT)
                    break;
                index++;
            }
            writerWorker.prepareClose();
            logger.info(startDate + "---" + tableName + "---Read.End");
            return totalCount;
        }
        catch (Exception e) {
            throw new GameRuntimeException(e, "MysqlDataReadWorker fail. tableName={%s}, errorMsg={%s} ",tableName, e.getMessage());
        }
    }

}

 

5）单表写入任务线程

/***
 * 
 * 
 * @描述 mysql数据导出任务
 */
public class DumpWriteWorkerLogic implements Callable<Integer> {

    private static final Logger logger = LoggerFactory.getLogger(DumpWriteWorkerLogic.class);
    private String tableName;// 表名

    private AtomicBoolean alive; // 线程是否活着

    private BufferedWriter writer;

    private ArrayBlockingQueue<String> queue; // 消息队列

    private ServerPO server;// 服务器

    private String startDate;// 开始时间

    private Map<String, Integer> resultDBMap;// 当天某服某表数量记录

    private GameType gameType;

    private SourceType sourceType;// 数据来源类型

    public DumpWriteWorkerLogic(ServerPO server, String tableName, String startDate, Map<String, Integer> resultDBMap, GameType gameType,
            SourceType sourceType) {
        CheckUtil.checkNotNull("DumpWriteWorkerLogic.tableName", tableName);
        CheckUtil.checkNotNull("DumpWriteWorkerLogic.server", server);
        CheckUtil.checkNotNull("DumpWriteWorkerLogic.startDate", startDate);
        CheckUtil.checkNotNull("DumpWriteWorkerLogic.resultDBMap", resultDBMap);
        CheckUtil.checkNotNull("DumpWriteWorkerLogic.gameType", gameType);
        CheckUtil.checkNotNull("DumpWriteWorkerLogic.sourceType", sourceType);

        this.tableName = tableName;
        this.server = server;
        this.startDate = startDate;
        this.queue = new ArrayBlockingQueue<>(65536);
        this.alive = new AtomicBoolean(true);
        this.gameType = gameType;
        this.sourceType = sourceType;
        this.writer = createWriter();
        this.resultDBMap = resultDBMap;

        logger.info("DumpWriteWorkerLogic Reg. tableName={}", this.tableName);
    }

    /***
     * 建立writer, 若文件不存在，会新建文件
     * 
     * @param serverId
     * @return
     */
    private BufferedWriter createWriter() {
        try {
            File toFile = FileUtils.getFilenameOfDumpTable(sourceType, tableName, startDate, gameType, ".txt");
            if (!toFile.exists()) {
                FileUtils.createFile(sourceType, tableName, startDate, gameType);
            }
            return new BufferedWriter(new OutputStreamWriter(new FileOutputStream(toFile, true), Charsets.UTF_8), 5 * 1024 * 1024);
        } catch (Exception e) {
            throw new GameRuntimeException(e, "DumpWriteWorkerLogic createWriter fail. server={%s}, errorMsg={%s} ",server.getId(), e.getMessage());
        }
    }

    /***
     * 写入文件
     * 
     * @param line
     *            一条记录
     */
    private void writeToFile(String line) {
        try {
            this.writer.write(line + "\n");
        } catch (Exception e) {
            throw new GameRuntimeException(e, "DumpWriteWorkerLogic writeToFile fail. errorMsg={%s} ", e.getMessage());
        }
    }

    /**
     * 记录数据到消息队列; 若是消息队列满了, 会阻塞直到能够put为止
     * 
     * @param result
     */
    public void putToWriterQueue(String line) {

        CheckUtil.checkNotNull("DumpWriteWorkerLogic putToWriterQueue", line);

        try {
            queue.put(line);
        } catch (InterruptedException e) {
            throw new GameRuntimeException(e, "DumpWriteWorkerLogic putToWriterQueue fail. errorMsg={%s} ", e.getMessage());
        }
    }

    /**
     * 准备关闭 (通知一下"须要处理的用户数据都处理完毕了"; task 写完数据, 就能够完毕了)
     */
    public void prepareClose() {
        alive.set(false);
    }

    @Override
    public Integer call() {
        logger.info("DumpWriteWorkerLogic Start. tableName={}", this.tableName);
        try {
            int totalCount = 0;
            while (alive.get() || !queue.isEmpty()) {
                List<String> dataList = new ArrayList<String>();
                queue.drainTo(dataList);
                int count = processDataList(dataList);
                totalCount += count;
            }
            logger.info("DumpWriteWorkerLogic ---" + startDate + "---" + tableName + "---Writer.End");
            return totalCount;
        } catch (Exception exp) {
            throw new GameRuntimeException(exp, "DumpWriteWorkerLogic call() fail. errorMsg={%s} ", exp.getMessage());
        } finally {
            FileUtil.close(this.writer);
        }
    }

    /***
     * 处理数据：写入本地文件及map
     * 
     * @param dataList
     *            数据集合
     * @return
     */
    private int processDataList(List<String> dataList) {
        int totalCount = 0;

        // 全部记录
        String key = server.getId() + "#" + tableName + "#" + sourceType.getIndex();
        if (dataList != null && dataList.size() > 0) {

            for (String line : dataList) {

                // 按行写入文件
                writeToFile(line);

                // 记录到result_data_record_count
                if (resultDBMap.get(key) != null) {
                    resultDBMap.put(key, resultDBMap.get(key) + 1);
                }
                else {
                    resultDBMap.put(key, 1);
                }

                totalCount++;
            }
        }

        return totalCount;
    }

}

内存优化

一、使用Jdbc方式获取数据，若是这个数据表比较大，那么获取数据的速度特别慢；

二、这个进程还会占用很是大的内存，而且GC不掉。分析缘由，Jdbc获取数据的时候，会一次将全部数据放入到内存，若是同步的数据表很是大，那么甚至会将内存撑爆。

那么优化的方法是让Jdbc不是一次所有将数据拿到内存，而是分页获取，每次最大limit数设置为50000，请参考read线程。

 

通过这种架构优化后，5000W数据大约花费40min可完成导出

 

说明：

由于本文只是记录项目的设计过程，详细的代码后面会开源。