Java四种线程池的使用

最新推荐文章于 2022-10-29 01:11:30 发布

wsb8233696

最新推荐文章于 2022-10-29 01:11:30 发布

阅读量192

点赞数

分类专栏：线程池文章标签：多线程

本文链接：https://blog.csdn.net/wsb8233696/article/details/105754061

版权

线程池专栏收录该内容

2 篇文章 0 订阅

订阅专栏

为什么要使用线程池？

为了减少创建和销毁线程的次数，让每个线程可以多次使用,可根据系统情况调整执行的线程数量，防止消耗过多内存,所以我们可以使用线程池.

Java通过Executors提供四种线程池，分别为：

newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

(1) newCachedThreadPool
创建一个可缓存线程池，如果线线程池大小超过了处理任务所需的线程，那么就会回收部分空闲（一般是60秒无执行）的线程，若无可回收，则新建线程。示例代码如下：

Java代码收藏代码

package test;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolExecutorTest {
public static void main(String[] args) {
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
for (int i = 0; i < 10; i++) {
final int index = i;
try {
Thread.sleep(index * 1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
cachedThreadPool.execute(new Runnable() {
public void run() {
System.out.println(index);
}
});
}
}
}

线程池为无限大，当执行第二个任务时第一个任务已经完成，会复用执行第一个任务的线程，而不用每次新建线程。

(2) newFixedThreadPool
创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。示例代码如下：

Java代码收藏代码

package test;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolExecutorTest {
public static void main(String[] args) {
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
for (int i = 0; i < 10; i++) {
final int index = i;
fixedThreadPool.execute(new Runnable() {
public void run() {
try {
System.out.println(index);
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
}
}
}

因为线程池大小为3，每个任务输出index后sleep 2秒，所以每两秒打印3个数字。
定长线程池的大小最好根据系统资源进行设置。如Runtime.getRuntime().availableProcessors()

(3) newScheduledThreadPool
创建一个定长线程池，支持定时及周期性任务执行。延迟执行示例代码如下：

Java代码收藏代码

package test;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class ThreadPoolExecutorTest {
public static void main(String[] args) {
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
scheduledThreadPool.schedule(new Runnable() {
public void run() {
System.out.println("delay 3 seconds");
}
}, 3, TimeUnit.SECONDS);
}
}

表示延迟3秒执行。

定期执行示例代码如下：

Java代码收藏代码

package test;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class ThreadPoolExecutorTest {
public static void main(String[] args) {
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
public void run() {
System.out.println("delay 1 seconds, and excute every 3 seconds");
}
}, 1, 3, TimeUnit.SECONDS);
}
}

表示延迟1秒后每3秒执行一次。

(4) newSingleThreadExecutor
创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。示例代码如下：

Java代码收藏代码

package test;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolExecutorTest {
public static void main(String[] args) {
ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
for (int i = 0; i < 10; i++) {
final int index = i;
singleThreadExecutor.execute(new Runnable() {
public void run() {
try {
System.out.println(index);
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
}
}
}

结果依次输出，相当于顺序执行各个任务。

ExcutorService中的excutor和submit方法的区别

两者都是将一个线程任务添加到线程池中并执行；
1、excutor没有返回值，submit有返回值，并且返回执行结果Future对象
2、excutor不能提交Callable任务，只能提交Runnable任务，submit两者任务都可以提交
3、在submit中提交Runnable任务，会返回执行结果Future对象，但是Future调用get方法将返回null（Runnable没有返回值）

使用场景：

使用多线程任务校验被保人数据；
1、每个被保人都是一个线程任务，
2、每个线程任务执行完都需要告诉主线程执行成功还是失败
3、这里需要submit提交Callable任务返回Future对象，并通过Future.get方法来获取执行结果

本地代码示例：

1.传统spring项目：

调用接口：

public class HmoPushOrderServiceImpl implements HmoPushOrderService {

  @Override 
public ResponseDTO<Boolean> pushHmoUserToPingAn() {
        ResponseDTO<Boolean> res = new ResponseDTO<Boolean>();
        ExecutorService threadPool = PingAnUserActivateTaskThreadPool.getInstance().getThreadPool();
        threadPool.submit(new PingAnActivateThreadTask());
        res.setResult(ResponseCode.SUCCESS, "触发成功", Boolean.TRUE);
        return res;
    }

异步线程池创建类：

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

public class PingAnUserActivateTaskThreadPool {

    // 最大线程数
    private static final int MAX_QUEUE_SIZE = 5;

    private static ExecutorService exc = null;

    private static volatile PingAnUserActivateTaskThreadPool instance = null;

    private PingAnUserActivateTaskThreadPool() {
        exc = Executors.newFixedThreadPool(MAX_QUEUE_SIZE);
    }

    /**
     *
     * @return
     */
    public static PingAnUserActivateTaskThreadPool getInstance() {
        if (instance == null) {
            synchronized (PingAnUserActivateTaskThreadPool.class) {
                if (instance == null) {
                    instance = new PingAnUserActivateTaskThreadPool();
                }
            }
        }
        return instance;
    }

    public ExecutorService getThreadPool() {
        return exc;
    }

}

任务执行类：

public class PingAnActivateThreadTask implements Runnable {

    public PingAnActivateThreadTask() {
        hmoPushOrderManager = SpringContextUtil.getBean("hmoPushOrderManager");
        msgSender = SpringContextUtil.getBean("msgSender");
        configUtils = SpringContextUtil.getBean("configUtils");
        apiUserBindManager = SpringContextUtil.getBean("apiUserBindManager");
    }

    @Override
    public void run() {
        ...
    }
}

2.spring-boot项目：

业务Controller：

@RestController
@RequestMapping("hfxyk/")
public class HfxykDataController {
   @Resource
    private ExecutorService taskExecutor;

    taskExecutor.submit(new Runnable() {
                @Override
                public void run() {
                       ...
                }
    }
}

线程池配置公用类：

import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;


@Configuration
public class ThreadPoolConfig {

    /**
     * 公共业务线程池
     *
     * @return
     */
    @Bean(name = "taskExecutor")
    public ExecutorService executorService() {
        ThreadFactory namedThreadFactory = new ThreadFactoryBuilder().setNameFormat("executor-hfxyk-pool-%d").build();
        return new ThreadPoolExecutor(2, 8, 1000, TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(20), namedThreadFactory, new ThreadPoolExecutor.DiscardPolicy());
    }
}

注意：DiscardPolicy策略：对拒绝任务直接无声抛弃，没有异常信息。

你可以使用JDK自带的监控工具来监控我们创建的线程数量，运行一个不终止的线程，创建指定量的线程，来观察：
工具目录：C:\Program Files\Java\jdk1.6.0_06\bin\jconsole.exe
运行程序做稍微修改：

Java代码收藏代码

package test;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolExecutorTest {
public static void main(String[] args) {
ExecutorService singleThreadExecutor = Executors.newCachedThreadPool();
for (int i = 0; i < 100; i++) {
final int index = i;
singleThreadExecutor.execute(new Runnable() {
public void run() {
try {
while(true) {
System.out.println(index);
Thread.sleep(10 * 1000);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}

效果如下：

选择我们运行的程序：

监控运行状态

wsb8233696

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java四种线程池的使用

Java通过Executors提供四种线程池，分别为：newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。newS...
复制链接

扫一扫

专栏目录