java线程池的使用，实现大量数据的更新操作

最新推荐文章于 2024-08-10 20:11:23 发布
最新推荐文章于 2024-08-10 20:11:23 发布
阅读量6.2k 收藏 17
点赞数 4
分类专栏： thread 文章标签： java 线程池 数据 多线程 线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qiyongkang520/article/details/47904863
版权 
在大量数据更新处理时，单个线程的执行速度过于缓慢，使用多线程可以大幅度的提高执行速度，下面我们来看看具体如何使用java线程池。

第一步，创建一个线程池（单例），用于实例化线程池，记录线程执行相关信息。

package com.qiyongkang.thread.threadpool.test2.common;

import java.util.ArrayList;
import java.util.Hashtable;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.logging.Logger;

public class ThreadPool {
    private static ThreadPool instance = null;

    private final ExecutorService executorService;

    private static Long RUNNING_THREAD_COUNT = 0L;

    private static Long startTime = 0L;

    private static long successFutureCount = 0L;

    private static long failFutureCount = 0L;

    private static List<Future<?>> futureList = new ArrayList<Future<?>>();

    private static Map<String, Future<?>> futureMonitorMap = new Hashtable<String, Future<?>>();

    private static Long executeTimeLimit = 72000000L;

    private ThreadPool(int maxSize, long executeTimeLimit) {

        executorService = new ThreadPoolExecutor(maxSize, maxSize, 10L, TimeUnit.SECONDS,
                new ArrayBlockingQueue<Runnable>(100000));
        ThreadPool.executeTimeLimit = executeTimeLimit;
        ThreadPool.startTime = System.currentTimeMillis();
    }

    public static ThreadPool getThreadPool() {
        return instance;
    }

    public synchronized static ThreadPool getInstance(int maxSize, final Logger contextLogger, long executeTimeLimit) {
        if (null == instance) {
            instance = new ThreadPool(maxSize, executeTimeLimit);
        }
        return instance;
    }

    public synchronized static ThreadPool getInstance(int maxSize, final Logger contextLogger) {
        if (null == instance) {
            instance = new ThreadPool(maxSize, executeTimeLimit);
        }
        return instance;
    }

    public synchronized static void startThreadTask() {
        increCount();
    }

    public synchronized static void finishThreadTask() {
        reduceCount();
    }

    private synchronized static void increCount() {
        RUNNING_THREAD_COUNT++;
    }

    private synchronized static void reduceCount() {
        RUNNING_THREAD_COUNT--;
    }

    public static Long getRunningThreadCount() {
        return RUNNING_THREAD_COUNT;
    }

    public int getQueueSize() {
        ThreadPoolExecutor executor = ((ThreadPoolExecutor) executorService);
        return executor.getQueue().size();
    }

    public Future<?> runThread(Runnable runnable) {
        Future<?> futureTask = null;
        try {
            futureTask = executorService.submit(runnable);
            futureList.add(futureTask);
            futureMonitorMap.put(String.valueOf(System.currentTimeMillis()), futureTask);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return futureTask;
    }

    public void shutdown() {
        if (executorService != null) {
            executorService.shutdown();
        }
    }

    public void shutdownNow() {
        if (executorService != null) {
            executorService.shutdownNow();
        }
    }

    public void finishThread() {
        instance.shutdown();
        while (true) {
            Long executeTime = System.currentTimeMillis() - startTime;
            if (ThreadPool.getRunningThreadCount() <= 0 || (executeTime >= executeTimeLimit)) {
                // 已经运行完毕或超时
                ThreadPoolExecutor executor = ((ThreadPoolExecutor) executorService);
                System.out.println("多线程执行完毕,线程任务总数为:" + executor.getTaskCount() + ",线程执行成功数目为:"
                        + executor.getCompletedTaskCount());
                instance.shutdown(); // Disable new tasks from being
                                     // submitted
                try {
                    // Wait a while for existing tasks to terminate
                    if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
                        executor.shutdownNow(); // Cancel currently
                                                // executing tasks
                        // Wait a while for tasks to respond to being
                        // cancelled
                        if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
                            System.err.println("Pool did not terminated");
                        }
                    }
                } catch (InterruptedException ie) {
                    // (Re-)Cancel if current thread also interrupted
                    executor.shutdownNow();
                }
                break;
            } else {
                operateFutureList();
            }
            try {
                Thread.sleep(5000);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    private synchronized void operateFutureList() {

        for (int i = 0; i < futureList.size(); i++) {
            Future<?> f = futureList.get(i);
            try {
                if (f.isDone()) {
                    successFutureCount++;
                    futureList.remove(i);
                    continue;
                }
                ThreadPoolExecutor executor = ((ThreadPoolExecutor) executorService);
                Long executeTime = System.currentTimeMillis() - startTime;
                if (executeTime >= 36000000 && executor.getQueue().size() <= 0) {
                    f.get(20, TimeUnit.MINUTES);
                }
            } catch (Exception e) {
                failFutureCount++;
                futureList.remove(i);
                try {
                    f.cancel(true);
                } catch (Exception e2) {
                    e2.printStackTrace();
                }
            }
        }

    }

    public static long getSuccessFutureCount() {
        return successFutureCount;
    }

    public static void setSuccessFutureCount(long successFutureCount) {
        ThreadPool.successFutureCount = successFutureCount;
    }

    public static long getFailFutureCount() {
        return failFutureCount;
    }

    public static void setFailFutureCount(long failFutureCount) {
        ThreadPool.failFutureCount = failFutureCount;
    }

}

第二步，创建一个抽象任务父类，用于将执行线程添加线程池。

package com.qiyongkang.thread.threadpool.test2.common;

import java.util.List;

public abstract class BaseTask<T> {

    protected void executeColl(List<T> coll) throws InterruptedException {

        int threadPerRecord = 1000;

        int times = 0;
        int size = coll.size();
        if (size % threadPerRecord == 0) {
            times = size / threadPerRecord;
        } else {
            times = size / threadPerRecord + 1;
        }

        ThreadPool pool = ThreadPool.getThreadPool();
        for (int i = 0; i < times; i++) {

            int start = i * threadPerRecord;
            int length = (size - (i + 1) * threadPerRecord) >= 0 ? threadPerRecord : (size - i * threadPerRecord);
            List<T> records = null;

            records = coll.subList(start, start + length);

            BaseDealDataService<T> dealDataService = getDealService();

            TaskThread<T> tmTaskThread = new TaskThread<T>(records, dealDataService);

            pool.runThread(tmTaskThread);
        }
    }

    protected abstract BaseDealDataService<T> getDealService();
}

第三步，创建一个抽象处理数据service父类。

package com.qiyongkang.thread.threadpool.test2.common;

import java.util.List;

public abstract class BaseDealDataService<T> {
    public abstract void dealData(List<T> data);
}

第四步，创建单个任务执行线程类。

package com.qiyongkang.thread.threadpool.test2.common;

import java.util.List;


public class TaskThread<T> implements Runnable {

    private BaseDealDataService<T> dealDataService;

    private List<T> dealDatas;

    public TaskThread(List<T> dealDatas, final BaseDealDataService<T> dealDataService) {
        this.dealDatas = dealDatas;
        this.dealDataService = dealDataService;
    }

    @Override
    public void run() {

        try {
            Thread.currentThread().getName();
            System.out.println(Thread.currentThread().getName() + "此线程开始执行");
            ThreadPool.startThreadTask();
            dealDataService.dealData(dealDatas);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            ThreadPool.finishThreadTask();
            System.out.println(Thread.currentThread().getName() + "此线程结束执行");
        }
    }

}

第五步，具体的处理数据服务类

package com.qiyongkang.thread.threadpool.test2;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

import com.qiyongkang.thread.threadpool.test2.common.BaseDealDataService;
import com.qiyongkang.thread.threadpool.test2.model.User;

public class TestService extends BaseDealDataService<User> {

    @Override
    public void dealData(List<User> data) {
        List<Object[]> list = new ArrayList<Object[]>();
        for (User user : data) {
            Object[] arr = new Object[] {user.getId(), user.getUserName(), user.getAge()};
            list.add(arr);
        }
        String sqlTemplate = "INSERT INTO user1(id, userName, age) VALUES(?, ?, ?)";

        Connection conn = getConn();

        System.out.println("开始批量插入：" + sqlTemplate);
        batchUpdate(sqlTemplate, list, conn);
    }

    public static void batchUpdate(String sqlTemplate, List<Object[]> list, Connection conn) {
        PreparedStatement ps = null;
        try {
            ps = conn.prepareStatement(sqlTemplate);
            conn.setAutoCommit(false);
            int size = list.size();
            Object[] o = null;
            for (int i = 0; i < size; i++) {
                o = list.get(i);
                for (int j = 0; j < o.length; j++) {
                    ps.setObject(j + 1, o[j]);
                }
                ps.addBatch();
            }

            ps.executeBatch();
            conn.commit();
            conn.setAutoCommit(true);
        } catch (SQLException e) {
            e.printStackTrace();
            try {
                conn.rollback();
                conn.setAutoCommit(true);
            } catch (SQLException e1) {
                e1.printStackTrace();
            }
        } finally {
            if(ps != null) {
                try {
                    ps.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    public static Connection getConn() {
        Connection conn = null;
        try {
            conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/test", "root", "root");
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return conn;
    }
}

第六步，具体的任务类，决定调用哪个服务类，以及总体的业务逻辑

package com.qiyongkang.thread.threadpool.test2;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.logging.Logger;

import com.qiyongkang.thread.threadpool.test2.common.BaseDealDataService;
import com.qiyongkang.thread.threadpool.test2.common.BaseTask;
import com.qiyongkang.thread.threadpool.test2.common.ThreadPool;
import com.qiyongkang.thread.threadpool.test2.model.User;

public class TestTask extends BaseTask<User> {

    public void doInternal() {
        //清空数据
        System.out.println("开始清空表数据");
        trucateData();
        System.out.println("结束清空表数据");

        ThreadPool pool = ThreadPool.getInstance(30, Logger.getLogger("TestTask1"));

        System.out.println("开始查询");

        //从数据库查询一个集合
        List<User> userList = new ArrayList<User>();
        for (int i = 0; i < 100000; i++) {
            User user = new User();
            user.setId(i + 1);
            user.setUserName("qiyongkang" + (i + 1));
            user.setAge(i + 1);
            userList.add(user);
        }
        System.out.println("结束查询,总数为：" + userList.size());

        int loop = userList.size() / 10000;

        for (int i = 0; i < loop; i++) {
            List<User> subList = userList.subList(i * 10000, i * 10000 + 10000);
            try {
                executeColl(subList);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //关闭线程池
        pool.finishThread();

    }

    private void trucateData() {
        Connection conn = TestService.getConn();
        PreparedStatement ps = null;
        try {
            ps = conn.prepareStatement("TRUNCATE TABLE user1");
            ps.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            try {
                ps.close();
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    @Override
    protected BaseDealDataService<User> getDealService() {
        return new TestService();
    }

    public static void main(String[] args) {
        try {
            Class.forName("com.mysql.jdbc.Driver");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        new TestTask().doInternal();
        System.out.println("程序结束");
    }

}

这里，笔者只是讲了讲线程池的使用，具体线程池的原理没有提及，如有什么疑问可以留言！
qiyongkang520
关注
专栏目录
使用java线程实现亿级数据处理
CVPR收割机的博客
12-08 663
多线程是指在程序中同时执行多个线程的机制。通过使用多线程，我们可以将任务拆分为多个子任务，并利用多个线程同时进行处理，从而提高整体的处理速度。Java中提供了丰富的多线程支持，可以通过继承Thread类或实现Runnable接口来创建线程。
【java线程池处理大量数据】
weixin_45581158的博客
02-16 620
java线程池处理大量数据示例如下执行结果 示例如下 public class MainThread { public static void main(String[] args) { List metricList = new ArrayList<>(); metricList.add(“测试1”); metricList.add(“测试2”); metricList.add(“测试3”); metricList.add(“测试4”); try { ExecutorService exec
如何在Java中实现多线程数据处理：从理论到实践
最新发布
微赚淘客系统开发者博客
08-10 738
大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！今天我们将详细探讨如何在Java中实现多线程数据处理，从理论到实际应用，展示如何利用多线程技术提高数据处理的效率。框架，以及实际应用中的多线程处理技巧，我们可以更有效地利用多线程技术提升系统性能。在实际开发中，选择合适的多线程技术和策略，将有助于实现高效、稳定的数据处理。在多线程环境中，多个线程可能会同时访问和修改共享数据，这可能导致数据不一致或其他并发问题。每个线程都是程序中的一个执行路径，多个线程可以并发执行，互不干扰。
大数据处理系列之（一）Java线程池使用
weixin_34005042的博客
06-14 155
前言：最近在做分布式海量数据处理项目，使用到了java的线程池，所以搜集了一些资料对它的使用做了一下总结和探究， 前面介绍的东西大多都是从网上搜集整理而来。文中最核心的东西在于后面两节无界队列线程池和有界队列线程池的实例 使用以及线上问题处理方案。 1. 为什么要用线程池？ 在Java中，如果每当一个请求到...
JAVA用线程池模拟查询大批量数据
qq_45830276的博客
08-27 1271
在开发过程中可能会碰到某些独特的业务，比如查询全部表数据，数据量过多会导致查询变得十分缓慢。如果使用了多线程，相当于多倍的速度去查询数据，极大的提高了效率。
Java 使用线程池分批插入或者更新数据
Zxdth的博客
06-11 2497
public void batchDeal(List data ,Integer batchNum) { int totalNum = data.size(); int pageNum = totalNum % batchNum == 0 ? totalNum / batchNum : totalNum / batchNum + 1; ExecutorService executor = Executors.newFixedThreadPool(pageNum); try {..
JAVA使用线程池查询大批量数据
05-09
本文将深入探讨如何在Java中使用线程池来查询大量数据，以及这样做的好处和实现方法。 首先，理解线程池的概念至关重要。线程池是一种多线程处理形式，预先创建了若干个线程，当有任务需要执行时，会从线程池中取出...
通过EasyExcel+线程池实现百万级数据从Excel导入到数据库
03-26
在处理大量数据导入数据库的场景中，使用阿里巴巴开源的EasyExcel库结合线程池技术可以有效地实现从Excel文件导入到数据库的过程。先定义sheet的数量和固定大小的线程池数量，每个sheet页做为单独的任务交给线程池...
一种类似JAVA线程池的C++线程池实现方法
08-25
不过，需要注意的是，虽然这种实现借鉴了Java线程池的设计思想，但C++标准库并没有提供内置的线程池实现，因此自定义线程池需要考虑平台兼容性、线程同步、错误处理等问题。此外，对于大型项目，可能还需要考虑...
Java中的线程池如何实现，一文彻底搞懂
程序媛小琬的博客
10-13 2025
在 HotSpot VM 的线程模型中，Java 线程被一对一映射为内核线程。 Java 在使用线程执行程序时，需要调用操作系统内核的 API，创建一个内核线程，操作系统要为线程分配一系列的资源；当该 Java 线程被终止时，这个内核线程也会被回收。因此 Java 线程的创建与销毁的成本很高，从而增加系统的性能开销。 除此之外，无限制地创建线同样会给系统带来性能问题。因为 CPU核数是有限的，大量的线程上下文切换会增加系统的性能开销。同时无限制地创建线程还可能导致 OOM。
java多线程处理数据库数据
09-21
java多线程处理数据库数据，使用并发包,无框架，可批量处数据库数据，进行增删改。。等等操作。
java多线程实现大批量数据导入源码
09-29
java多线程实现大批量数据切分成指定份数的数据，然后多线程处理入库或者导出，线程的个数和每份数据的数量都可以控制
多线程处理大量数据 java
热门推荐
tiantian929的博客
09-27 1万+
项目场景： 简述项目相关背景： 例如：获取大量数据并处理，生成execl文件导出 问题描述： 5W条数据处理后生成execl文件需要6个小时，效率慢 APP 中接收数据代码： @Override public void run() { bytes = mmInStream.read(buffer); mHandler.obtainMessage(READ_DATA, bytes, -1, buffer).sendToTarget();
java 多线程处理大量并发数据
weixin_42973163的博客
07-18 2528
多线程处理并发数据
java多线程处理百万数据
weixin_44039105的博客
08-11 6651
java实现多线程处理数据
Java使用线程池批量处理数据操作
weixin_44030476的博客
03-06 5896
1.如何保证数据按顺序批量处理 2.如何保证数据全部处理完统一返回 3.如何保证是多任务异步操作 4.如何提高运行效率，减少运行时间
Java 多线程批量处理数据
记录工作开发中遇到的技术难点，方便自己查看，也希望可以帮助到他人...
11-07 2993
在项目开发中需要处理100万多的数据，这些数据需要从mysql数据库中读取出来，再通过调用其他平台的接口推送数据。由于时间紧迫，数据需要在短时间内完成推送，采用单线程推送很慢，所以采用多线程推送来提高效率。
JAVA - 大批量集合数据多线程处理
a985548426的博客
04-25 5555
大批量数据多线程处理 原因：最近写项目多时候遇到一个这样的问题，Excel批量导入表格，数据量较大，处理时间较长。然后小编想到了可以用多线程处理。 例： //导入失败集合 List<BatchPayDetail...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值