JAVA线程缓存池

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

(1) newCachedThreadPool
创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程。示例代码如下:

Java代码  

  1. package test;
  2. import java.util.concurrent.ExecutorService;
  3. import java.util.concurrent.Executors;
  4. public class ThreadPoolExecutorTest {
  5. public static void main(String[] args) {
  6. ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
  7. for (int i = 0; i < 10; i++) {
  8. final int index = i;
  9. try {
  10. Thread.sleep(index * 1000);
  11. } catch (InterruptedException e) {
  12. e.printStackTrace();
  13. }
  14. cachedThreadPool.execute(new Runnable() {
  15. public void run() {
  16. System.out.println(index);
  17. }
  18. });
  19. }
  20. }
  21. }

线程池为无限大,当执行第二个任务时第一个任务已经完成,会复用执行第一个任务的线程,而不用每次新建线程。
 
(2) newFixedThreadPool
创建一个定长线程池,可控制线程最大并发数,超出的线程会在队列中等待。示例代码如下:

Java代码  

  1. package test;
  2. import java.util.concurrent.ExecutorService;
  3. import java.util.concurrent.Executors;
  4. public class ThreadPoolExecutorTest {
  5. public static void main(String[] args) {
  6. ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
  7. for (int i = 0; i < 10; i++) {
  8. final int index = i;
  9. fixedThreadPool.execute(new Runnable() {
  10. public void run() {
  11. try {
  12. System.out.println(index);
  13. Thread.sleep(2000);
  14. } catch (InterruptedException e) {
  15. e.printStackTrace();
  16. }
  17. }
  18. });
  19. }
  20. }
  21. }

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

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

Java代码  

  1. package test;
  2. import java.util.concurrent.Executors;
  3. import java.util.concurrent.ScheduledExecutorService;
  4. import java.util.concurrent.TimeUnit;
  5. public class ThreadPoolExecutorTest {
  6. public static void main(String[] args) {
  7. ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
  8. scheduledThreadPool.schedule(new Runnable() {
  9. public void run() {
  10. System.out.println("delay 3 seconds");
  11. }
  12. }, 3, TimeUnit.SECONDS);
  13. }
  14. }

表示延迟3秒执行。

定期执行示例代码如下:

Java代码  

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

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

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

Java代码  

  1. package test;
  2. import java.util.concurrent.ExecutorService;
  3. import java.util.concurrent.Executors;
  4. public class ThreadPoolExecutorTest {
  5. public static void main(String[] args) {
  6. ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
  7. for (int i = 0; i < 10; i++) {
  8. final int index = i;
  9. singleThreadExecutor.execute(new Runnable() {
  10. public void run() {
  11. try {
  12. System.out.println(index);
  13. Thread.sleep(2000);
  14. } catch (InterruptedException e) {
  15. e.printStackTrace();
  16. }
  17. }
  18. });
  19. }
  20. }
  21. }

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

时间: 2024-10-12 22:03:21

JAVA线程缓存池的相关文章

Java线程池应用

Executors工具类用于创建Java线程池和定时器. newFixedThreadPool:创建一个可重用固定线程数的线程池,以共享的无界队列方式来运行这些线程.在任意点,在大多数 nThreads 线程会处于处理任务的活动状态.如果在所有线程处于活动状态时提交附加任务,则在有可用线程之前,附加任务将在队列中等待.如果在关闭前的执行期间由于失败而导致任何线程终止,那么一个新线程将代替它执行后续的任务(如果需要).在某个线程被显式地关闭之前,池中的线程将一直存在. 创建一个固定大小的线程池来执

java线程池

1.new Thread的弊端 执行一个异步任务你还只是如下new Thread吗? 1 new Thread(new Runnable() { 2 3 @Override 4 public void run() { 5 // TODO Auto-generated method stub 6 } 7 }).start(); 那你就out太多了,new Thread的弊端如下: a. 每次new Thread新建对象性能差. b. 线程缺乏统一管理,可能无限制新建线程,相互之间竞争,及可能占用过

Java线程池使用说明

Java线程池使用说明 一 简介 线程的使用在java中占有极其重要的地位,在jdk1.4极其之前的jdk版本中,关于线程池的使用是极其简陋的.在jdk1.5之后这一情况有了很大的改观.Jdk1.5之后加入了java.util.concurrent包,这个包中主要介绍java中线程以及线程池的使用.为我们在开发中处理线程的问题提供了非常大的帮助. 二:线程池 线程池的作用: 线程池作用就是限制系统中执行线程的数量.     根 据系统的环境情况,可以自动或手动设置线程数量,达到运行的最佳效果:少

java线程池原理及实现方式

线程池的定义 线程池是一种多线程处理形式,处理过程中将任务添加到队列,然后在创建线程后自动启动这些任务.线程池线程都是后台线程 为什么要使用线程池 1.减少在创建和销毁线程上所花的时间以及系统资源的开销 2.在一个 JVM 里创建太多的线程可能会导致系统由于过度消耗内存而用完内存或"切换过度".为了防止资源不足,服务器应用程序需要一些办法来限制任何给定时刻处理的请求数目. 线程池组成部分 1.线程池管理器(ThreadPoolManager):用于创建并管理线程池,包括 创建线程池,销

Java 线程池学习

Reference: <创建Java线程池>[1],<Java线程:新特征-线程池>[2], <Java线程池学习>[3],<线程池ThreadPoolExecutor使用简介>[4],<Java5中的线程池实例讲解>[5],<ThreadPoolExecutor使用和思考>[6] [1]中博主自己通过ThreadGroup实现一个线程池(挺方便理解的),使用的是jdk1.4版本,Jdk1.5版本以上提供了现成的线程池. [2]中介绍

java线程池分析和应用

比较 在前面的一些文章里,我们已经讨论了手工创建和管理线程.在实际应用中我们有的时候也会经常听到线程池这个概念.在这里,我们可以先针对手工创建管理线程和通过线程池来管理做一个比较.通常,我们如果手工创建线程,需要定义线程执行对象,它实现的接口.然后再创建一个线程对象,将我们定义好的对象执行部分装载到线程中.对于线程的创建.结束和结果的获取都需要我们来考虑.如果我们需要用到很多的线程时,对线程的管理就会变得比较困难.我们手工定义线程的方式在时间和空间效率方面会存在着一些不足.比如说我们定义好的线程

JAVA线程池应用的DEMO

在做很多高并发应用的时候,单线程的瓶颈已经满足不了我们的需求,此时使用多线程来提高处理速度已经是比较常规的方案了.在使用多线程的时候,我们可以使用线程池来管理我们的线程,至于使用线程池的优点就不多说了. Java线程池说起来也简单,简单说下继承关系: ThreadPoolExecutor extends AbstractExecutorService implements ExecutorService extends Executor 还有一个支持延时执行线程和可以重复执行线程的实现类: Sc

浅聊JAVA 线程池的一般用法

一.为什么要用线程池 1).降低资源消耗,通过重复利用已创建的线程降低线程的创建和销毁造成的消耗. 2).提高响应速度,当任务到达时,任务可以不需要等到线程创建就能立即执行. 3).提高线程的可管理性,线程是稀缺资源,如果无限制的创建,不仅会消耗系统资源,还会降低系统的稳定性,使用线程池可以进行统一的分配,调优和监控. 二.注意 1).需要对线程池原理了如指掌. 三.线程的常见用法 1).New Thread. 2).Thread Pool. 四.New Thread 常见用法 new  thr

Java线程池的那些事

熟悉java多线程的朋友一定十分了解java的线程池,jdk中的核心实现类为java.util.concurrent.ThreadPoolExecutor.大家可能了解到它的原理,甚至看过它的源码:但是就像我一样,大家可能对它的作用存在误解.现在问题来了,jdk为什么要提供java线程池?使用java线程池对于每次都创建一个新Thread有什么优势? 对线程池的误解 很长一段时间里我一直以为java线程池是为了提高多线程下创建线程的效率.创建好一些线程并缓存在线程池里,后面来了请求(Runnab