Java 四种线程池

最新推荐文章于 2024-07-26 22:36:20 发布
最新推荐文章于 2024-07-26 22:36:20 发布
阅读量239 收藏
点赞数
分类专栏： Java

一、线程池简介：

多线程技术主要解决处理器单元内多个线程执行的问题，它可以显著减少处理器单元的闲置时间，增加处理器单元的吞吐能力。

假设一个服务器完成一项任务所需时间为：T1 创建线程时间，T2 在线程中执行任务的时间，T3 销毁线程时间。

如果：T1 + T3 远大于 T2，则可以采用线程池，以提高服务器性能。

一个线程池包括以下四个基本组成部分：

1、线程池管理器(ThreadPool)：用于创建并管理线程池，包括 创建线程池，销毁线程池，添加新任务;

2、工作线程(PoolWorker)：线程池中线程，在没有任务时处于等待状态，可以循环的执行任务;

3、任务接口(Task)：每个任务必须实现的接口，以供工作线程调度任务的执行，它主要规定了任务的入口，任务执行完后的收尾工作，任务的执行状态等;

4、任务队列(taskQueue)：用于存放没有处理的任务。提供一种缓冲机制。

线程池技术正是关注如何缩短或调整T1,T3时间的技术，从而提高服务器程序性能的。它把T1，T3分别安排在服务器程序的启动和结束的时间段或者一些空闲的时间段，这样在服务器程序处理客户请求时，不会有T1，T3的开销了。

线程池不仅调整T1,T3产生的时间段，而且它还显著减少了创建线程的数目，看一个例子：

假设一个服务器一天要处理50000个请求，并且每个请求需要一个单独的线程完成。在线程池中，线程数一般是固定的，所以产生线程总数不会超过线程池中线程的数目，而如果服务器不利用线程池来处理这些请求则线程总数为50000。一般线程池大小是远小于50000。所以利用线程池的服务器程序不会为了创建50000而在处理请求时浪费时间，从而提高效率。

代码实现中并没有实现任务接口，而是把Runnable对象加入到线程池管理器(ThreadPool)，然后剩下的事情就由线程池管理器(ThreadPool)来完成了

二、java类库中提供的线程池简介：

java提供的线程池更加强大，相信理解线程池的工作原理，看类库中的线程池就不会感到陌生了。

\

\

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

 

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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
packagetest;importjava.util.concurrent.ExecutorService;importjava.util.concurrent.Executors;publicclassThreadPoolExecutorTest{publicstaticvoidmain(String[]args){ExecutorServicecachedThreadPool=Executors.newCachedThreadPool(); for (inti= 0 ;i< 10 ;i++){finalintindex=i; try {Thread.sleep(index* 1000 );} catch (InterruptedExceptione){e.printStackTrace();}cachedThreadPool.execute(newRunnable(){publicvoidrun(){System.out.println(index);}});}}}
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
创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。示例代码如下：
 

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
packagetest;importjava.util.concurrent.ExecutorService;importjava.util.concurrent.Executors;publicclassThreadPoolExecutorTest{publicstaticvoidmain(String[]args){ExecutorServicefixedThreadPool=Executors.newFixedThreadPool( 3 ); for (inti= 0 ;i< 10 ;i++){finalintindex=i;fixedThreadPool.execute(newRunnable(){publicvoidrun(){ try {System.out.println(index);Thread.sleep( 2000 );} catch (InterruptedExceptione){e.printStackTrace();}}});}}}
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
创建一个定长线程池，支持定时及周期性任务执行。延迟执行示例代码如下：
 

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
packagetest;importjava.util.concurrent.Executors;importjava.util.concurrent.ScheduledExecutorService;importjava.util.concurrent.TimeUnit;publicclassThreadPoolExecutorTest{publicstaticvoidmain(String[]args){ScheduledExecutorServicescheduledThreadPool=Executors.newScheduledThreadPool( 5 );scheduledThreadPool.schedule(newRunnable(){publicvoidrun(){System.out.println( "delay3seconds" );}}, 3 ,TimeUnit.SECONDS);}}
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秒执行。

定期执行示例代码如下：
 

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
packagetest;importjava.util.concurrent.Executors;importjava.util.concurrent.ScheduledExecutorService;importjava.util.concurrent.TimeUnit;publicclassThreadPoolExecutorTest{publicstaticvoidmain(String[]args){ScheduledExecutorServicescheduledThreadPool=Executors.newScheduledThreadPool( 5 );scheduledThreadPool.scheduleAtFixedRate(newRunnable(){publicvoidrun(){System.out.println( "delay1seconds,andexcuteevery3seconds" );}}, 1 , 3 ,TimeUnit.SECONDS);}}
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, 优先级)执行。示例代码如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
packagetest;importjava.util.concurrent.ExecutorService;importjava.util.concurrent.Executors;publicclassThreadPoolExecutorTest{publicstaticvoidmain(String[]args){ExecutorServicesingleThreadExecutor=Executors.newSingleThreadExecutor(); for (inti= 0 ;i< 10 ;i++){finalintindex=i;singleThreadExecutor.execute(newRunnable(){publicvoidrun(){ try {System.out.println(index);Thread.sleep( 2000 );} catch (InterruptedExceptione){e.printStackTrace();}}});}}}
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();
      }
     }
    });
   }
  }
}


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

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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
packagetest;importjava.util.concurrent.ExecutorService;importjava.util.concurrent.Executors;publicclassThreadPoolExecutorTest{publicstaticvoidmain(String[]args){ExecutorServicesingleThreadExecutor=Executors.newCachedThreadPool(); for (inti= 0 ;i< 100 ;i++){finalintindex=i;singleThreadExecutor.execute(newRunnable(){publicvoidrun(){ try { while ( true ){System.out.println(index);Thread.sleep( 10 * 1000 );}} catch (InterruptedExceptione){e.printStackTrace();}}}); try {Thread.sleep( 500 );} catch (InterruptedExceptione){e.printStackTrace();}}}}
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();
    }
   }
  }
}


效果如下：

\

选择我们运行的程序：

\

监控运行状态


N_Saber
关注
专栏目录
java 四种 线程池
FREEDOM
10-14 8510
java通过Executors提供四种线程池，分别为： newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。 newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。 newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
Java四种线程池的使用共6页.pdf.zip
10-29
Java线程池是Java并发编程中的重要组成部分，它在多线程环境下的资源管理与任务调度方面发挥着关键作用。本资料"Java四种线程池的使用共6页.pdf.zip"详细介绍了Java中四种主要的线程池实现，旨在帮助开发者更有效地...
Executor 当n个任务要运行，线程池设为m，那么同时可运行m个，当m中的任意一个完成后，从剩余的（n-m）中在加入一个运行
CTLLIN的专栏
04-16 1118
package com.ctl.util.ThreadPool; import java.util.concurrent.Executor; import java.util.concurrent.Executors; public class Demo03 { public static void main(String[] args) { // execute 执行器利用 工厂方法生
java四种线程池
csgarten的博客
07-16 1044
一、四种线程池 Java通过Executors提供四种线程池，分别为： 1、newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。 2、newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。 3、newScheduledThreadPool 创建一个可定期或者延时执行任务的定长线程池，支持定时及周期性任务执行。 ...
Java四种线程池的使用
hq.zheng的博客
05-30 2675
一、普通new Thread线程 new Thread(()->{}).start(); 缺点： 每次new Thread新建对象性能差，线程缺乏统一管理，可能无限制新建线程，相互之间竞争，及可能占用过多系统资源导致死机或oom，缺乏更多功能，如定时执行、定期执行、线程中断。 二、Java线程池 Java通过Executors提供四种线程池： 1）、newCachedThr...
Java 四种线程池的用法分析
热门推荐
stromxu 的专栏
03-31 8万+
介绍new Thread的弊端及Java四种线程池的使用，对Android同样适用，本文是基础篇。转载请标注原地址：http://blog.csdn.net/u011974987/article/details/51027795；1、new Thread的弊端执行一个异步任务你还只是如下new Thread吗？ new Thread(new Runnable() { @Override
【Java中的四种线程池】
记录各种Bug解决案例及日常学习内容
05-17 5742
目录1、CachedThreadPool - 可缓存线程池2、FixedThreadPool - 定长线程池3、SingleThreadExecutor - 单线程池4、ScheduledThreadPool - 调度线程池 在Java.util.concurrent中，提供了工具类Executors(调度器)对象来创建线程池，可创建的线程池有四种： 1、CachedThreadPool - 可缓存线程池 特点：无限大，如果线程池中没有可用线程就会自动创建，有的话就自动利用起来。 2、FixedThre
Java四种线程池的使用详解
qfikh的博客
09-27 5052
Java通过Executors提供四种线程池，分别为：  newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。 newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。  newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
Java—常见4种线程池详解
weixin_44991038的博客
07-26 1522
java中常见4种线程池—SingleThreadExecutor、FixedThreadPool、CacheThreadPool、ScheduledThreadPool
Java四种线程池类
liuhaikang的博客
06-18 1808
Java中四种具有不同功能常见的线程池。他们都是直接或者间接配置 ThreadPoolExecutor来实现他们各自的功能。这四种线程池分别是 newFixedThreadPool,newCachedThreadPool,newScheduledThreadPool和 newSingleThreadExecutor。这四个线程池可以通过Executors类获取。 ...
Java四种线程池创建方式
花&败
09-04 722
​​​​​​​。
Java四种线程池的简单介绍.docx
06-28
### Java 四种线程池的详细介绍 #### 1. `newCachedThreadPool`：创建一个可缓存线程池 - **定义与特点**： - `newCachedThreadPool` 创建了一个可缓存线程池，它能够根据当前的处理需求灵活调整线程数量。 - 当...
对 Java 四种线程池的简要分析
12-21
Java线程池是一种高效管理线程资源的方式，它允许开发者预先配置一组线程，以便在需要时复用，而不是每次需要执行任务时都创建新的线程。线程池的顶级接口`Executor`定义了调度任务的基本操作，而实际的线程池实现由...
java 四种线程池实例
06-06
本文将深入探讨四种常见的Java线程池实例：`ThreadPoolExecutor`、`Executors`提供的固定线程池、单线程池和定时线程池。 1. **ThreadPoolExecutor**: 这是最基础也是最灵活的线程池实现，可以通过`new ...
Matlab Toolbox for Interval Type-2 Fuzzy Logic Systems.rar
最新发布
09-20
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
基于java的大学生第二课堂设计与实现.docx
09-20
基于java的大学生第二课堂设计与实现.docx
vue+SpringBoot442大学校园快递代取管理系统的设计与实现java毕业设计源码含论文.rar
09-20
jdk版本:jdk1.8+ 前端：vue.js+ElementUI 开发工具：IDEA 或者eclipse都支持 编程语言: java 框架支持：springboot 数据库: mysql 版本不限 数据库工具：Navicat/SQLyog都可以 详细技术：java+springboot+vue+MYSQL+MAVEN 前端采用的Vue框架，后端采用java语言，sprinboot框架，mybatis操作数据源，使用软件：idea,eclipse、MySQL。完成了用户登录管理等模块的设计与实现。完成了系统数据库的设计，并基于MySQL数据库管理系统
win和android安卓平台的播放器 .zip(毕设&课设&实训&大作业&竞赛&项目)
09-20
项目工程资源经过严格测试可直接运行成功且功能正常的情况才上传，可轻松复刻，拿到资料包后可轻松复现出一样的项目，本人系统开发经验充足（全领域），有任何使用问题欢迎随时与我联系，我会及时为您解惑，提供帮助。 【资源内容】：包含完整源码+工程文件+说明（如有）等。答辩评审平均分达到96分，放心下载使用！可轻松复现，设计报告也可借鉴此项目，该资源内项目代码都经过测试运行成功，功能ok的情况下才上传的。 【提供帮助】：有任何使用问题欢迎随时与我联系，我会及时解答解惑，提供帮助 【附带帮助】：若还需要相关开发工具、学习资料等，我会提供帮助，提供资料，鼓励学习进步 【项目价值】：可用在相关项目设计中，皆可应用在项目、毕业设计、课程设计、期末/期中/大作业、工程实训、大创等学科竞赛比赛、初期项目立项、学习/练手等方面，可借鉴此优质项目实现复刻，设计报告也可借鉴此项目，也可基于此项目来扩展开发出更多功能 下载后请首先打开README文件（如有），项目工程可直接复现复刻，如果基础还行，也可在此程序基础上进行修改，以实现其它功能。供开源学习/技术交流/学习参考，勿用于商业用途。质量优质，放心下载使用。
深入解析Java四种线程池用法与优势
总结起来，使用Java线程池的优势包括： - **性能提升**：通过重用现有线程，减少了频繁的对象创建和销毁，提高了执行效率。 - **资源管理**：线程池能够控制并发数，避免过多竞争，降低系统阻塞和内存消耗。 - **...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值