线程池（五）：线程池使用场景问题

最新推荐文章于 2025-11-06 21:12:11 发布
原创 最新推荐文章于 2025-11-06 21:12:11 发布 · 1.1k 阅读 · 25 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#jenkins #线程池 #java

线程池（五）：线程池使用场景问题

线程池（五）：线程池使用场景问题

1 线程池使用场景CountDownLatch、Future

1.1 CountDownLatch

CountDownLatch是Java并发包中的一个同步辅助类。它允许一个或多个线程等待直到在其他线程中执行的一组操作完成。

原理

CountDownLatch内部维护了一个计数器，该计数器的初始值为需要等待完成的操作数量。当一个线程调用countDown()方法时，计数器会减1。而调用await()方法的线程会被阻塞，直到计数器的值变为0，此时所有等待的线程会被释放继续执行。

示例代码
import java.util.concurrent.CountDownLatch;

public class CountDownLatchExample {
    public static void main(String[] args) throws InterruptedException {
        int numThreads = 5;
        CountDownLatch latch = new CountDownLatch(numThreads);

        for (int i = 0; i < numThreads; i++) {
            new Thread(() -> {
                try {
                    // 模拟线程执行任务
                    Thread.sleep(1000);
                    System.out.println(Thread.currentThread().getName() + " 任务完成");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    latch.countDown();
                }
            }).start();
        }

        // 主线程等待所有子线程完成任务
        latch.await();
        System.out.println("所有任务已完成，主线程继续执行");
    }
}

1.2 案例一（es数据批量导入）

需求分析

在将大量数据导入Elasticsearch（ES）时，为了提高导入效率，通常会采用多线程并发导入的方式。但是，在所有数据导入完成之前，可能需要等待所有线程执行完毕，才能进行后续的操作，比如数据校验、通知用户导入完成等。

实现步骤
  1. 初始化CountDownLatch：根据要并发导入的任务数量，初始化CountDownLatch的计数器值。例如，如果要分10个线程并发导入数据，计数器初始值就设为10。
  2. 创建线程执行导入任务：在每个线程中，编写数据导入ES的逻辑。在导入完成后，调用countDown()方法将计数器减1。
  3. 主线程等待：主线程调用await()方法，阻塞等待计数器变为0，即所有数据导入线程都完成任务。
示例代码
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.xcontent.XContentType;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;

public class EsBulkImport {
    private static final RestHighLevelClient client = new RestHighLevelClient(); // 假设已正确初始化ES客户端
    private static final int BATCH_SIZE = 1000; // 每批导入的数据量
    private static final int THREAD_COUNT = 10; // 并发线程数

    public static void main(String[] args) throws InterruptedException {
        List<DataObject> dataList = new ArrayList<>(); // 假设已准备好要导入的数据
        CountDownLatch latch = new CountDownLatch(THREAD_COUNT);

        for (int i = 0; i < THREAD_COUNT; i++) {
            int startIndex = i * BATCH_SIZE;
            int endIndex = Math.min((i + 1) * BATCH_SIZE, dataList.size());
            List<DataObject> subList = dataList.subList(startIndex, endIndex);

            new Thread(() -> {
                BulkRequest bulkRequest = new BulkRequest();
                for (DataObject data : subList) {
                    bulkRequest.add(client.prepareIndex()
                           .setSource(data.toJson(), XContentType.JSON)
                           .request());
                }
                try {
                    BulkResponse bulkResponse = client.bulk(bulkRequest);
                    if (bulkResponse.hasFailures()) {
                        // 处理失败情况
                        System.err.println("导入失败: " + bulkResponse.buildFailureMessage());
                    } else {
                        System.out.println("部分数据导入成功");
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                } finally {
                    latch.countDown();
                }
            }).start();
        }

        latch.await();
        System.out.println("所有数据导入完成");
    }

    static class DataObject {
        // 假设数据对象有相关属性和方法
        public String toJson() {
            // 转换为JSON字符串的逻辑
            return "{}";
        }
    }
}

1.3 案例二（数据汇总）

需求分析

在一个系统中，可能需要从多个不同的数据源（如不同的数据库表、不同的API接口等）获取数据，然后将这些数据进行汇总分析。为了提高获取数据的效率，可以使用多线程并发从各个数据源获取数据，最后再进行汇总。

实现步骤
  1. 初始化CountDownLatch：根据数据源的数量，设置CountDownLatch的计数器值。比如有5个数据源，计数器就初始化为5。
  2. 创建线程获取数据：每个线程负责从一个数据源获取数据。获取完成后，调用countDown()方法。
  3. 汇总数据：主线程在调用await()方法等待所有数据获取线程完成后，进行数据汇总操作。
示例代码
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;

public class DataAggregation {
    public static void main(String[] args) throws InterruptedException {
        int numSources = 5;
        CountDownLatch latch = new CountDownLatch(numSources);
        List<Integer> dataList = new ArrayList<>();

        for (int i = 0; i < numSources; i++) {
            new Thread(() -> {
                try {
                    // 模拟从数据源获取数据
                    int data = getDataSourceData();
                    dataList.add(data);
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    latch.countDown();
                }
            }).start();
        }

        latch.await();

        int sum = 0;
        for (int data : dataList) {
            sum += data;
        }
        System.out.println("汇总后的数据: " + sum);
    }

    private static int getDataSourceData() {
        // 模拟从数据源获取数据的逻辑，这里简单返回一个随机数
        return (int) (Math.random() * 100);
    }
}

1.4 案例三（异步调用）

需求分析

在一些业务场景中，需要发起多个异步调用（如调用多个远程服务接口），并且在所有异步调用完成后，再进行统一的处理（如合并结果、更新状态等）。使用CountDownLatch可以方便地实现这种等待所有异步操作完成的需求。

实现步骤
  1. 初始化CountDownLatch：根据异步调用的数量设置计数器值。例如有3个异步调用，计数器初始值设为3。
  2. 发起异步调用：在每个线程中发起异步调用（可以是通过网络请求远程服务等操作）。调用完成后，调用countDown()方法。
  3. 统一处理：主线程调用await()方法等待所有异步调用线程完成，然后进行后续的统一处理逻辑。
示例代码
import java.util.concurrent.CountDownLatch;

public class AsyncInvocation {
    public static void main(String[] args) throws InterruptedException {
        int numCalls = 3;
        CountDownLatch latch = new CountDownLatch(numCalls);

        for (int i = 0; i < numCalls; i++) {
            new Thread(() -> {
                try {
                    // 模拟异步调用，这里简单睡眠一段时间
                    Thread.sleep(1000);
                    System.out.println(Thread.currentThread().getName() + " 异步调用完成");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    latch.countDown();
                }
            }).start();
        }

        latch.await();
        System.out.println("所有异步调用完成，进行统一处理");
    }
}

2 如何控制某个方法允许并发访问线程的数量

2.1 方法一：使用Semaphore（信号量）

原理

Semaphore是Java并发包中的一个类，它通过控制内部的许可证数量来限制同时访问的线程数量。可以初始化Semaphore并指定许可证的数量，当一个线程想要访问受保护的资源（如某个方法）时，需要先获取许可证（调用acquire()方法），使用完后释放许可证（调用release()方法）。如果没有可用的许可证，线程将被阻塞，直到有其他线程释放许可证。

示例代码
import java.util.concurrent.Semaphore;

public class SemaphoreExample {
    private static final Semaphore semaphore = new Semaphore(3); // 允许同时3个线程访问

    public static void accessMethod() {
        try {
            semaphore.acquire();
            System.out.println(Thread.currentThread().getName() + " 进入方法");
            // 模拟方法执行逻辑，这里简单睡眠一段时间
            Thread.sleep(1000);
            System.out.println(Thread.currentThread().getName() + " 离开方法");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            semaphore.release();
        }
    }

    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            new Thread(() -> accessMethod()).start();
        }
    }
}

2.2 方法二：使用线程池（ThreadPoolExecutor）

原理

线程池可以控制线程的创建、复用和销毁，并且可以设置核心线程数、最大线程数等参数。通过合理设置这些参数，可以间接控制并发访问某个方法的线程数量。例如，设置核心线程数和最大线程数为相同的值，就可以限制同时执行任务（访问方法）的线程数量。

示例代码
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolExample {
    private static final ExecutorService executorService = Executors.newFixedThreadPool(3); // 固定大小为3的线程池

    public static void accessMethod() {
        System.out.println(Thread.currentThread().getName() + " 进入方法");
        // 模拟方法执行逻辑，这里简单睡眠一段时间
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " 离开方法");
    }

    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            executorService.submit(() -> accessMethod());
        }
        executorService.shutdown();
    }
}

2.3 方法三：使用ReentrantLock结合条件变量（Condition）

原理

ReentrantLock是可重入锁，它提供了比synchronized更灵活的锁机制。通过结合条件变量（Condition），可以实现更精细的线程同步控制。可以使用一个计数器来记录当前正在访问方法的线程数量，当达到限制数量时，新的线程通过条件变量等待，当有线程离开方法时，通知等待的线程。

示例代码
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class LockConditionExample {
    private static final ReentrantLock lock = new ReentrantLock();
    private static final Condition condition = lock.newCondition();
    private static int activeThreads = 0;
    private static final int MAX_THREADS = 3;

    public static void accessMethod() {
        lock.lock();
        try {
            while (activeThreads >= MAX_THREADS) {
                try {
                    condition.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            activeThreads++;
            System.out.println(Thread.currentThread().getName() + " 进入方法");
            // 模拟方法执行逻辑，这里简单睡眠一段时间
            Thread.sleep(1000);
            System.out.println(Thread.currentThread().getName() + " 离开方法");
            activeThreads--;
            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            new Thread(() -> accessMethod()).start();
        }
    }
}

以上详细介绍了线程池使用场景中涉及的CountDownLatch、Future相关内容，以及控制方法并发访问线程数量的多种方式，并通过丰富的代码示例进行了说明。

线程池详解：线程池七大核心参数、线程池工作原理、线程池的创建方式、线程池的拒绝策略、如何合理分配线程池大小
小小鱼儿小小林的博客
03-19 1万+
线程池是一种用于管理和复用线程的机制，它允许我们在需要执行一些并发任务时，可以重复使用已经创建好的线程，而不是每次都创建新的线程。这样可以减少线程创建和销毁的开销，提高系统的性能和响应速度。并发线程池的优点包括： 提高系统的性能和吞吐量，因为可以重复使用已经创建好的线程，减少线程创建和销毁的开销。 可以控制并发任务的执行顺序和数量，从而避免系统资源被过度占用。 可以设置线程池的参数，如核心线程数、最大线程数、任务队列等，以满足不同场景的需求。
线程池多线程在项目中的实际应用
The best are water的博客
04-22 1402
线程、线程池在项目中的实际应用
【线程池】线程池的使用案例
weixin_44823875的博客
03-20 9419
多线程-- 线程池（1）自定义线程池（2）java自带的线程池 （1）自定义线程池 （1）为什么使用线程池 每一个线程的启动和结束都是比较消耗时间和占用资源的。使用线程池的过程中创建固定数量的线程，不用创建多余新的线程，而是循环使用那些已经存在的线程。 （2）自定义线程池设计思路 1-准备一个任务容器 2-一次性启动10个消费者线程 3-刚开始任务容器是空的，所以线程都wait在上面 4-直到一个外部线程往这个任务容器中扔了一个“任务”，就会有一个消费者线程被唤醒 5-这个消费者线程取出“任务”，并且执行这
CountDownLatch 使用
最新发布
weixin_37926313的博客
11-06 920
✅Do初始化CountDownLatch(count = 任务数)；在finally块中调用；使用避免无限等待；结合或线程安全集合收集结果；线程池使用有界队列 + 自定义拒绝策略。❌Don't不要在任务中直接操作主线程逻辑；不要复用已归零的；不要忽略。
线程池+CountDownLatch 处理大集合
zhanghe687的博客
03-16 2724
场景：有一个需求：首先从数据库中取出上千条数据，然后需要逐条对数据进行分析，例如分析情感/是否重复等多项分析。 解决：将取出来的上千条，分批+多线程处理。 public class CountDownLatchTest { public static void main(String[] args) { ArrayList<String> list = new ArrayList<String>(); for (int i = 0;
线程池的各种使用场景
热门推荐
星空dream的博客
04-04 3万+
（1）高并发、任务执行时间短的业务，线程池线程数可以设置为CPU核数+1，减少线程上下文的切换 （2）并发不高、任务执行时间长的业务要区分开看：        a）假如是业务时间长集中在IO操作上，也就是IO密集型的任务，因为IO操作并不占用CPU，所以不要让所有的CPU闲下来，可以加大线程池中的线程数目，让CPU处理更多的业务        b）假如是业务时间长集中在计算操作上，也就是计算密集型...
Python 线程池详解：从基础使用到高级实践
2402_85519509的博客
08-12 1674
本文详细介绍了Python线程池的使用方法和优化技巧。线程池通过复用线程减少创建销毁开销，特别适合IO密集型任务。文章讲解了ThreadPoolExecutor模块的基本操作（创建、提交任务、关闭）、高级功能（结果处理、并发控制）以及max_workers参数设置指南，并提供了网页爬取的实战案例。同时指出了GIL限制、线程安全等常见问题及解决方案。最后对比了线程池与其他并发方案的优缺点，帮助开发者根据任务类型选择合适方案，提升程序性能。
【Java并发编程】基于ExecutorService的线程池管理：多任务调度与执行结果获取机制设计
10-30
使用场景及目标：①掌握线程池的类型选择与合理配置，避免资源浪费或性能瓶颈；②理解定时任务的实现原理，正确使用scheduleAtFixedRate和scheduleWithFixedDelay；③熟练运用Future和Callable进行异步结果获取与...
深入理解线程池：原理、使用场景及最佳实践
2402_87283759的博客
09-16 751
线程池是一种重用线程资源的机制，它预先创建一组可复用的线程，由统一的调度器管理任务的分配与执行。开发者不再需要手动创建线程，而是将任务提交给线程池，由其内部线程自动执行。使用线程池在 Java 开发中的意义尤为突出：例如，在 Tomcat、Netty 等 Web 容器中，底层都依赖线程池处理海量并发请求；在大数据处理或异步任务调度中， 和 也扮演着关键角色。可以说，掌握线程池，是每一个 Java 工程师迈向高并发编程的必经之路。接下来，我们将深入探讨线程池的工作原理、核心参数、使用场景以及最佳实践。在 J
Python 程序语言设计模式思路-并发模式：线程池模式：管理线程池，优化线程创建和销毁
05-22
在现代计算机科学中，多线程编程被广泛应用于并行处理和提高程序性能。然而，线程的创建和销毁是一个开销较大的...线程池模式适用于需要频繁执行大量短生命周期任务的场景，如服务器请求处理、并行计算和定时任务等。
线程池的经典应用场景
Danny_idea的博客
10-19 1万+
在日常的开发工作中，我们经常会需要使用到线程池这类型的组件。例如下边几种应用场景： 线程池经典应用场景 异步发送邮件通知 发送一个任务，然后注入到线程池中异步发送。 心跳请求任务 创建一个任务，然后定时发送请求到线程池中。 类似的场景有很多，我们下边一步一步地来介绍不同的应用场景下，线程池的具体使用案例： 异步发送邮件场景 定义一个简单的邮件发送接口： public interface SendEmailService { /** * 发送邮件 * * @param e
线程池使用场景
Flying_Fish_roe的博客
11-30 2123
大量的短期任务：线程池可以避免频繁地创建和销毁线程，提高任务的执行效率。IO 密集型任务：由于线程池可以异步执行任务，可以避免线程因等待IO导致的闲置，提高系统的并发处理能力。稳定的并发任务：线程池可以控制线程的数量，避免线程数量过多导致系统负载过高，同时保持系统的稳定性。并发任务均衡的情况：线程池可以自动管理任务的调度和执行，平衡任务之间的执行时间，提高系统的整体执行效率。需要限制系统资源的场景：通过限制线程池的大小，可以控制系统的最大并发数，避免系统资源被过度占用。
线程池常见使用场景
yvya_的博客
08-12 536
本文介绍了线程池在四种典型场景下的应用：1）异步任务处理：通过线程池异步执行非实时任务（如通知发送），提升用户体验；2）批量数据处理：采用多线程并行处理大批量操作（如数据迁移），显著提高吞吐量；3）网络请求并发：并发调用多个外部服务（如API接口），缩短总体响应时间；4）定时任务执行：利用ScheduledThreadPoolExecutor实现周期性任务（如缓存清理）。每种场景都提供了Java代码示例，展示了如何配置线程池参数及处理策略，以优化不同业务场景下的系统性能。
线程池的使用场景
weixin_40017062的博客
02-20 6704
线程池的使用场景
线程池应用场景使用
Ivyvivid的博客
07-23 1657
Future是Java 5添加的类，用来描述一个异步计算的结果。你可以使用isDone方法检查计算是否完成，或者使用get阻塞住调用线程，直到计算完成返回结果，你也可以使用cancel方法停止任务的执行。虽然Future以及相关使用方法提供了异步执行任务的能力，但是对于结果的获取却是很不方便，只能通过阻塞或者轮询的方式得到任务的结果。阻塞的方式显然和我们的异步编程的初衷相违背，轮询的方式又会耗费无谓的CPU资源，而且也不能及时地得到计算结果，为什么不能用观察者设计模式当计算结果完成及时通知监听者呢？
最强攻略:线程池的实际运用场景详细介绍（包看包会 代码详细 贴合实际）
qq_45944685的博客
12-21 2747
线程池的实际运用场景详细介绍（包看包会 代码详细 贴合实际）
【转载】从使用到原理学习Java线程池
weixin_30678821的博客
08-31 604
线程池的技术背景 在面向对象编程中，创建和销毁对象是很费时间的，因为创建一个对象要获取内存资源或者其它更多资源。在Java中更是如此，虚拟机将试图跟踪每一个对象，以便能够在对象销毁后进行垃圾回收。 所以提高服务程序效率的一个手段就是尽可能减少创建和销毁对象的次数，特别是一些很耗资源的对象创建和销毁。如何利用已有对象来服务就是一个需要解决的关键问题，其实这就是一些”池化资源”技术产生的原因。 ...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值