java常用线程池

齐穗穗

已于 2024-02-29 14:57:10 修改

阅读量1.1k

点赞数 8

分类专栏： Java 文章标签： java 开发语言

于 2024-02-29 14:03:31 首次发布

本文链接：https://blog.csdn.net/weixin_49990593/article/details/136365985

版权

Java 专栏收录该内容

19 篇文章 0 订阅

订阅专栏

常用线程池介绍

1:FixedThreadPool（固定大小线程池)

特点：线程池中的线程数量在创建时就被设定，并且是固定的。当有新的任务提交到线程池时，如果线程池中有空闲线程，则立即执行；若所有线程都在工作，则新任务会被放入队列中等待。
使用场景：适用于处理大量短生命周期的任务，且系统资源有限或者要求任务的响应时间较为稳定的情况。

2:CachedThreadPool（缓存型线程池)

特点：线程池会根据需要创建新的线程，理论上可以无限制地增长，同时它还试图回收并重用之前已经终止的线程，以减少创建新线程带来的性能开销。
使用场景：适合于处理大量耗时较短、并发量较大的任务，但需要注意控制系统的负载，防止由于线程过多而导致系统资源耗尽。

3:ScheduledThreadPool（定时线程池）

特点：主要用于执行定时任务和周期性任务，它同样是一个定长线程池，但在处理定时任务方面提供额外的功能支持。
使用场景：例如定期执行清理任务、数据统计等操作。

4:SingleThreadExecutor（单一线程池）

特点：线程池中只有一个线程来执行所有的任务，任务之间按照提交顺序进行串行执行。
使用场景：对于那些要求任务严格按照顺序执行，不允许SingleThreadScheduledExecutor**（单一定并发的情况非常适用。

5:ScheduledThreadPool

特点：它是 ScheduledThreadPool 的特殊形式，只包含一个线程，用于按计划顺序执行定时任务。

创建方式

这些线程池均基于 java.util.concurrent 包下的 ThreadPoolExecutor 类以及相关的工厂类如Executors 创建。使用时可以根据具体需求选择合适的线程池类型来优化程序的并发性能。

使用示例

1:FixedThreadPool示例

package org.springblade.test;

import lombok.extern.slf4j.Slf4j;
import org.apache.poi.ss.formula.functions.T;
import org.springblade.modules.gzfw.entity.GzfwYqjdEntity;
import org.springblade.modules.system.service.IDsfSjCcService;
import org.springblade.modules.system.service.impl.DsfSjCcServiceImpl;

import javax.annotation.Resource;
import java.lang.reflect.Field;
import java.sql.*;
import java.util.*;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;

@Slf4j
public class FixedThreadPoolTest {

    @org.junit.jupiter.api.Test
    public void fixedThreadPoolExample() {
        // 创建一个固定大小为5的线程池
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 5; i++){
            Runnable worker = new WorkerThread("" + i);
            executorService.execute(worker);
        }
        executorService.shutdown();
         // 关闭线程池，不再接受新任务并等待所有已提交的任务完成
        while (!executorService.isTerminated()){
        }
        System.out.println("所有任务已完成");
    }

}

class WorkerThread implements Runnable {
    private String command;

    public WorkerThread(String s) {
        this.command = s;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " 开始执行任务: " + command);
    }
}


    //执行结果
    //pool-1-thread-1 开始执行任务: 0
    // pool-1-thread-2 开始执行任务: 1
    // pool-1-thread-4 开始执行任务: 3
    // pool-1-thread-3 开始执行任务: 2
    // pool-1-thread-5 开始执行任务: 4
    // 所有任务已完成

2:CachedThreadPool示例

package org.springblade.test;

import lombok.extern.slf4j.Slf4j;
import org.apache.poi.ss.formula.functions.T;
import org.springblade.modules.gzfw.entity.GzfwYqjdEntity;
import org.springblade.modules.system.service.IDsfSjCcService;
import org.springblade.modules.system.service.impl.DsfSjCcServiceImpl;

import javax.annotation.Resource;
import java.lang.reflect.Field;
import java.sql.*;
import java.util.*;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;

@Slf4j
public class CachedThreadPoolTest {

    @org.junit.jupiter.api.Test
    public void cachedThreadPoolExample() {
        // 创建一个可以缓存线程并根据需要创建新线程的线程池
        ExecutorService executor = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) {
            Runnable worker = new WorkerThread("" + i);
            executor.execute(worker);
        }
        // 关闭线程池，不再接受新任务并尝试终止所有正在运行的任务
        executor.shutdown();
        while (!executor.isTerminated()) {
        }
        System.out.println("所有任务已完成");
    }
}


class WorkerThread implements Runnable {
    private String command;

    public WorkerThread(String s) {
        this.command = s;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " 开始执行任务: " + command);
    }
}

    //执行结果
    //pool-1-thread-2 开始执行任务: 1
    // pool-1-thread-1 开始执行任务: 0
    // pool-1-thread-4 开始执行任务: 3
    // pool-1-thread-3 开始执行任务: 2
    // pool-1-thread-5 开始执行任务: 4
    // pool-1-thread-6 开始执行任务: 5
    // pool-1-thread-7 开始执行任务: 6
    // pool-1-thread-8 开始执行任务: 7
    // pool-1-thread-9 开始执行任务: 8
    // pool-1-thread-10 开始执行任务: 9
    // 所有任务已完成

3:ScheduledThreadPool 示例

package org.springblade.test;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

@Slf4j
public class ScheduledThreadPool Test {

    @org.junit.jupiter.api.Test
    public void scheduledThreadPool Example() {
        // 创建一个定长的定时线程池，核心线程数为1
        ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
        // 提交一个周期性任务，每两秒执行一次
        executor.scheduleAtFixedRate(new Runnable() {
            public void run() {
                System.out.println("当前时间：" + System.currentTimeMillis());
            }
        }, 0, 2, TimeUnit.SECONDS);
        // 在6秒后关闭线程池（这将导致所有未执行的任务被取消）
        try {
            Thread.sleep(6000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        executor.shutdownNow();
    }
}
    //执行结果
    //当前时间：1709185507280
    // 当前时间：1709185509279
    // 当前时间：1709185511280

4:SingleThreadExecutor 示例

package org.springblade.test;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

@Slf4j
public class SingleThreadExecutor Test {

    @org.junit.jupiter.api.Test
    public void singleThreadExecutorExample() {
        // 创建单一线程的线程池
        ExecutorService executor = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            Runnable worker = new WorkerThread("" + i);
            executor.execute(worker);
        }
        // 关闭线程池
        executor.shutdown();
        while (!executor.isTerminated()) {
        }
        System.out.println("所有任务按顺序已完成");
    }
}

class WorkerThread implements Runnable {
    private String command;

    public WorkerThread(String s) {
        this.command = s;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " 开始执行命令: " + command);
    }
}
//执行结果
// pool-1-thread-1 开始执行命令: 0
// pool-1-thread-1 开始执行命令: 1
// pool-1-thread-1 开始执行命令: 2
// pool-1-thread-1 开始执行命令: 3
// pool-1-thread-1 开始执行命令: 4
// pool-1-thread-1 开始执行命令: 5
// pool-1-thread-1 开始执行命令: 6
// pool-1-thread-1 开始执行命令: 7
// pool-1-thread-1 开始执行命令: 8
// pool-1-thread-1 开始执行命令: 9
// 所有任务按顺序已完成

5:ScheduledThreadPool（定时调度线程池）

package org.springblade.test;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

@Slf4j
public class ScheduledThreadPoolTest {

    @org.junit.jupiter.api.Test
    public void scheduledThreadPoolExample() {
        // 创建一个定长的定时线程池，核心线程数为1
        ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
        // 提交一个周期性任务，每两秒执行一次
        executor.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println("当前时间：" + System.currentTimeMillis());
            }
        }, 0, 2, TimeUnit.SECONDS);

        // 在一段时间后（例如6秒后）关闭线程池
        try {
            Thread.sleep(6000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        executor.shutdownNow();
    }
}

    //执行结果
    //当前时间：1709186336571
    //当前时间：1709186338571
    //当前时间：1709186340570
    //当前时间：1709186342570