Java并发工具类（四）Semaphore - 文件读取

Java并发工具类（四）Semaphore - 文件读取

题记

生产环境大数据下发的存量数据较大，且是单一文件形式下发，由于该部分数据需要经过加工、判断后存入 elastic search，所以，最初的实现方案是单线程执行，该方案在增量阶段效率可满足生产要求，但是需求变更存量数据增加指标后处理效率缓慢，严重影响存量数据的准确性，不利于业务的扩张。

方案

根据当前交易的流程，在保证数据尽可能准确的前提下，如何提高效率是需要迫切解决的。

• 方案一

大数据方提供 http 接口，或者公司内部实现/开发的 rpc 框架 ，通过接口调用完成查询交易；

• 方案二

大数据下发文件时，按照条数对文件进行拆分，应用端采用多线程实现数据读取、加工、入库；

代码实现

由于大数据平台处于升级建设中，第一种方案暂不支持，由此，只能从应用端着手，保证交易正常的同时（该数据文件下发时间为 早 8点），实现效率提升。

文件读取

package com.zgclearn.project.myproject.file;

import java.io.*;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;


/**
 * 按照最大信号量要求，实现多线程读取文件 -> 写库
 * 需在约定的 D:\read\ 路径下 放入约定格式的文件
 */
public class SemaphoreReadFile {

    /**
     * 线程池；按需定义类型
     */
    ExecutorService service;

    /**
     * 信号量定义
     */
    Semaphore semaphore = new Semaphore(4);


    /**
     * 时分秒格式
     */
    private String FORMATTER = "yyyy-MM-dd HH:mm:ss:sss";

    /**
     * 自定义实现 Runnable 接口
     */
    class FileRunnable implements Runnable {

        // 文件名
        private String fileName;

        public FileRunnable(String fileName) {
            this.fileName = fileName;
        }


        /**
         * run 方法实现
         */
        @Override
        public void run() {

            // 读取文件
            File readfile = new File(fileName);
            InputStreamReader isr = null;
            long startTime = 0L;
            try {

                // 获取信号量
                semaphore.acquire();
                startTime = System.currentTimeMillis();

                System.out.println(new SimpleDateFormat(FORMATTER).format(startTime) + " ,线程:" + Thread.currentThread().getName() + " ,开始执行:" + fileName);

                // 文件流读取
                isr = new InputStreamReader(new FileInputStream(readfile), "UTF-8");
                BufferedReader reader = new BufferedReader(isr);
                String line = null;

                // 按行读取，读到 null 文件结束
                while ((line = reader.readLine()) != null) {
                    System.err.println(Thread.currentThread().getName() + " _ " + line);


                    // TODO 模拟实现
                    TimeUnit.SECONDS.sleep(5);
                }
                reader.close();
                isr.close();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                System.out.println(new SimpleDateFormat(FORMATTER).format(System.currentTimeMillis()) +
                        " ,线程:" + Thread.currentThread().getName() + " ,执行结束:" + fileName + " ,耗时: " + (System.currentTimeMillis() - startTime) / 1000);
                semaphore.release();
            }
        }

    }

    public static void main(String[] args) {

        new SemaphoreReadFile().execute("D:\\read\\", "test_");

    }

    /**
     * 多线程文件读取
     *
     * @param filePath
     * @param filePrix
     */
    public void execute(String filePath, String filePrix) {

        // 初始化线程池
        service = Executors.newCachedThreadPool();

        File file = new File(filePath);

        // 读取目录下所有文件
        if (file.isDirectory()) {
            String[] filelist = file.list();
            List<String> fList = new ArrayList<String>();

            // 遍历文件目录，文件名列表获取
            for (int i = 0; i < filelist.length; i++) {
                if (filelist[i].startsWith(filePrix) && filelist[i].endsWith(".txt")) {
                    fList.add(filePath.concat(filelist[i]));
                }
            }

            // 多线程读取，完成数据写入
            fList.forEach(f -> {
                FileRunnable fileRunnable = new FileRunnable(f);
                service.execute(fileRunnable);
            });
        }

        // 线程池关闭
        service.shutdown();
    }

}

执行结果

2022-12-29 15:36:46:046 ,线程:pool-1-thread-4 ,开始执行:D:\read\test_3.txt
2022-12-29 15:36:46:046 ,线程:pool-1-thread-3 ,开始执行:D:\read\test_2.txt
2022-12-29 15:36:46:046 ,线程:pool-1-thread-1 ,开始执行:D:\read\test_1.txt
2022-12-29 15:36:46:046 ,线程:pool-1-thread-2 ,开始执行:D:\read\test_10.txt
pool-1-thread-2 _ test_10
pool-1-thread-1 _ test_1
pool-1-thread-4 _ test_3
pool-1-thread-3 _ test_2
2022-12-29 15:36:51:051 ,线程:pool-1-thread-1 ,执行结束:D:\read\test_1.txt ,耗时: 5
2022-12-29 15:36:51:051 ,线程:pool-1-thread-2 ,执行结束:D:\read\test_10.txt ,耗时: 5
2022-12-29 15:36:51:051 ,线程:pool-1-thread-6 ,开始执行:D:\read\test_5.txt
2022-12-29 15:36:51:051 ,线程:pool-1-thread-5 ,开始执行:D:\read\test_4..txt
2022-12-29 15:36:51:051 ,线程:pool-1-thread-3 ,执行结束:D:\read\test_2.txt ,耗时: 5
2022-12-29 15:36:51:051 ,线程:pool-1-thread-4 ,执行结束:D:\read\test_3.txt ,耗时: 5
2022-12-29 15:36:51:051 ,线程:pool-1-thread-7 ,开始执行:D:\read\test_6.txt
2022-12-29 15:36:51:051 ,线程:pool-1-thread-8 ,开始执行:D:\read\test_7.txt
pool-1-thread-5 _ test_4
pool-1-thread-6 _ test_5
pool-1-thread-7 _ test_6
pool-1-thread-8 _ test_7
2022-12-29 15:36:56:056 ,线程:pool-1-thread-5 ,执行结束:D:\read\test_4..txt ,耗时: 5
2022-12-29 15:36:56:056 ,线程:pool-1-thread-9 ,开始执行:D:\read\test_8.txt
2022-12-29 15:36:56:056 ,线程:pool-1-thread-6 ,执行结束:D:\read\test_5.txt ,耗时: 5
2022-12-29 15:36:56:056 ,线程:pool-1-thread-10 ,开始执行:D:\read\test_9.txt
2022-12-29 15:36:56:056 ,线程:pool-1-thread-8 ,执行结束:D:\read\test_7.txt ,耗时: 5
2022-12-29 15:36:56:056 ,线程:pool-1-thread-7 ,执行结束:D:\read\test_6.txt ,耗时: 5
pool-1-thread-9 _ test_8
pool-1-thread-10 _ test_9
2022-12-29 15:37:01:001 ,线程:pool-1-thread-9 ,执行结束:D:\read\test_8.txt ,耗时: 5
2022-12-29 15:37:01:001 ,线程:pool-1-thread-10 ,执行结束:D:\read\test_9.txt ,耗时: 5

Process finished with exit code 0

总结

1. 保证当前交易正常可用；
2. 提高文件读取、加工、入库的效率；

相关文章推荐

Java并发工具类（一）CountDownLatch https://blog.csdn.net/shang_xs/article/details/87075550
Java并发工具类（二）CyclicBarrier https://blog.csdn.net/shang_xs/article/details/87077098
Java并发工具类（三）Exchanger https://blog.csdn.net/shang_xs/article/details/87078321
Java并发工具类（四）Semaphore https://blog.csdn.net/shang_xs/article/details/87090443