java线程池_2

合集下载

java线程池四种简单案例

java线程池四种简单案例java线程池四种简单案例⼀、固定线程池（固定线程个数）使⽤ ExecutorService pool=Executors.newFixedThreadPool(3); 创建⼀个初始线程为3个的线程池，如果超过这个线程个数，后⾯的线程会等待代码：package demo;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;/*** 固定线程池* 使⽤Executors.newFixedThreadPool(3)⽅法指定池中允许执⾏线程的个数* 如果超过这个线程个数,后⾯的线程就会等待*/public class FixedThreadPoolTest {public static void main(String[] args) {//创建⼀个初始线程为3个的线程池ExecutorService pool=Executors.newFixedThreadPool(3);for(int i=0;i<3;i++){final int task=i;pool.execute(new Runnable() {@Overridepublic void run() {try {Thread.sleep(20);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}for(int j=0;j<3;j++){System.out.println(Thread.currentThread().getName()+"正在进⾏第"+(task+1)+"个任务,第"+(j+1)+"次循环");}}});}//关闭线程池pool.shutdown();}} 执⾏结果：⼆、缓存线程池（不固定线程个数，池中线程不够，会⾃动增加线程个数）使⽤ ExecutorService pool=Executors.newCachedThreadPool(); 创建⼀个缓存线程池代码：package demo;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;/*** 缓存线程池* 如果池中的线程不够,会⾃动增加线程*/public class CachedThreadPoolTest {public static void main(String[] args) {//创建⼀个缓存线程池ExecutorService pool=Executors.newCachedThreadPool();for(int i=0;i<3;i++){final int task=i;pool.execute(new Runnable() {@Overridepublic void run() {try {Thread.sleep(20);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}for(int j=0;j<3;j++){System.out.println(Thread.currentThread().getName()+"正在进⾏第"+(task+1)+"个任务,第"+(j+1)+"次循环"); }}});}}} 执⾏结果：三、定时器线程池（定时执⾏线程）使⽤ ScheduledExecutorService pool = Executors.newScheduledThreadPool(3); 创建定时器线程池　代码：package demo;import java.util.concurrent.Executors;import java.util.concurrent.ScheduledExecutorService;import java.util.concurrent.TimeUnit;/*** 定时器线程池**/public class ScheduledThreadPoolTest {public static void main(String[] args) {method1();// method2();}/*** 2秒之后执⾏线程只执⾏⼀次*/public static void method1(){ScheduledExecutorService pool = Executors.newScheduledThreadPool(3);//2秒之后执⾏这个线程pool.schedule(new Runnable() {@Overridepublic void run() {System.out.println("爆炸");}}, 2, TimeUnit.SECONDS);}/*** 5秒后第⼀次执⾏线程，之后每隔2秒执⾏⼀次* 也就是5秒后打印第⼀次爆炸，之后每隔2秒打印⼀次爆炸*/public static void method2(){ScheduledExecutorService pool = Executors.newScheduledThreadPool(3);pool.scheduleAtFixedRate(new Runnable() {@Overridepublic void run() {System.out.println("爆炸");}}, 5, 2, TimeUnit.SECONDS);}} method1执⾏结果：（只执⾏⼀次） method2执⾏结果：四、单线程池（只有⼀个线程的线程池）使⽤ ExecutorService pool=Executors.newSingleThreadExecutor(); 创建⼀个单线程池代码：package demo;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;/*** 只有⼀个线程⼯作的线程池* 始终保持池中有⼀个线程，当⼀个线程死了会⽴即重新创建⼀个线程*/public class SingleThreadExecutorTest {public static void main(String[] args) {ExecutorService pool=Executors.newSingleThreadExecutor();for(int i=0;i<3;i++){final int task=i;pool.execute(new Runnable() {@Overridepublic void run() {try {Thread.sleep(20);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}for(int j=0;j<3;j++){System.out.println(Thread.currentThread().getName()+"正在进⾏第"+(task+1)+"个任务,第"+(j+1)+"次循环"); }}});}}} 执⾏结果：。

java线程池的使用例子

java线程池的使用例子随着计算机技术的不断发展，我们的软件系统越来越复杂，程序的性能要求也越来越高。

在这样的背景下，线程池成为了一种非常重要的工具。

Java线程池是Java提供的一种简单易用的线程管理工具，可以帮助我们更好地管理程序中的线程，提高程序的性能和稳定性。

本文将通过一个实际的例子来介绍Java线程池的使用方法和注意事项。

希望读者可以通过本文的学习，更好地掌握Java线程池的使用技巧。

一、什么是线程池？在介绍Java线程池之前，我们需要先了解什么是线程池。

线程池是一种管理线程的机制，可以帮助我们更好地管理程序中的线程，提高程序的性能和稳定性。

线程池的主要作用是为每个任务分配一个线程，当任务完成后，线程会被回收并可供下一个任务使用。

这样，线程的创建和销毁的开销就可以得到控制，避免了频繁创建和销毁线程所带来的性能损失。

二、Java线程池的使用方法1. 创建线程池Java线程池的创建方式非常简单，只需要使用ThreadPoolExecutor类即可。

以下是一个简单的线程池创建代码： ```ExecutorService executor =Executors.newFixedThreadPool(5);```这个代码创建了一个固定大小为5的线程池。

如果需要创建其他类型的线程池，可以使用其他的静态工厂方法，如newCachedThreadPool()、newSingleThreadExecutor()等。

2. 提交任务创建好线程池之后，我们就可以向线程池提交任务了。

以下是一个简单的线程池提交任务代码：```executor.submit(new Runnable() {@Overridepublic void run() {// 执行任务}});```这个代码提交了一个Runnable类型的任务，线程池会自动为其分配一个线程执行。

如果需要提交其他类型的任务，可以使用Callable、Future等接口。

【多线程】Java线程池七个参数详解

【多线程】Java线程池七个参数详解/*** Creates a new {@code ThreadPoolExecutor} with the given initial* parameters.** @param corePoolSize the number of threads to keep in the pool, even* if they are idle, unless {@code allowCoreThreadTimeOut} is set* @param maximumPoolSize the maximum number of threads to allow in the* pool* @param keepAliveTime when the number of threads is greater than* the core, this is the maximum time that excess idle threads* will wait for new tasks before terminating.* @param unit the time unit for the {@code keepAliveTime} argument* @param workQueue the queue to use for holding tasks before they are* executed. This queue will hold only the {@code Runnable}* tasks submitted by the {@code execute} method.* @param threadFactory the factory to use when the executor* creates a new thread* @param handler the handler to use when execution is blocked* because the thread bounds and queue capacities are reached* @throws IllegalArgumentException if one of the following holds:<br>* {@code corePoolSize < 0}<br>* {@code keepAliveTime < 0}<br>* {@code maximumPoolSize <= 0}<br>* {@code maximumPoolSize < corePoolSize}* @throws NullPointerException if {@code workQueue}* or {@code threadFactory} or {@code handler} is null*/public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler)⼀、corePoolSize 线程池核⼼线程⼤⼩线程池中会维护⼀个最⼩的线程数量，即使这些线程处理空闲状态，他们也不会被销毁，除⾮设置了allowCoreThreadTimeOut。

javaspringboot线程池以及多线程

javaspringboot线程池以及多线程线程和进程进程是资源分配的最⼩单位，线程是CPU调度的最⼩单位。

是不是很抽象，做个简单⽐喻，进程=⽕车，线程=车厢，线程在进程⾥运⾏（单个的车厢是⽆法运⾏的）；不同进程之间数据很难共享，同⼀进程下的线程数据共享则很容易。

多线程⼀个应⽤程序有多条执⾏路径（单线程：⼀个应⽤程序只有⼀条执⾏路径）。

应⽤场景异步，有些功能⽆需同步执⾏，可以使⽤另外⼀个线程去执⾏。

多个线程共同完成⼀个事情，缩短整体执⾏时间，同时cpu也得到了充分利⽤（例如，盖房⼦垒墙，⼀个⼈需要10天，10个⼈同时做，1天左右可以完成）。

线程池什么是线程池线程池，顾名思义，是存放了⼀堆线程的池⼦/容器，并且管理线程的整个⽣命周期。

java.util.concurrent.Executors提供了⼀个 java.util.concurrent.Executor接⼝的实现⽤于创建线程池。

为什么要⽤线程池1. 减少了创建和销毁线程的次数，每个⼯作线程都可以被重复利⽤，可执⾏多个任务。

2. 可以根据系统的承受能⼒，调整线程池中⼯作线线程的数⽬，防⽌因为消耗过多的内存，⽽把服务器累趴下(每个线程需要⼤约1MB内存，线程开的越多，消耗的内存也就越⼤，最后死机)。

实现⽅式此处以springboot实现⽅式为例import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;import org.springframework.scheduling.annotation.EnableAsync;import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;import java.util.concurrent.Executor;import java.util.concurrent.ThreadPoolExecutor;/*** @author lipeiguang*/@Configuration@EnableAsyncpublic class ThreadPoolConfig {@Bean(name = "executor")public Executor getAsyncThread() {ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();//线程池维护线程的最少数量taskExecutor.setCorePoolSize(5);//线程池维护线程的最⼤数量,只有在缓冲队列满了之后才会申请超过核⼼线程数的线程taskExecutor.setMaxPoolSize(10);//缓存队列taskExecutor.setQueueCapacity(20);//允许的空闲时间,当超过了核⼼线程出之外的线程在空闲时间到达之后会被销毁taskExecutor.setKeepAliveSeconds(200);//线程名称前缀taskExecutor.setThreadNamePrefix("my-thread-");// 线程池对拒绝任务（⽆线程可⽤）的处理策略，⽬前只⽀持AbortPolicy、CallerRunsPolicy；默认为后者taskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());// 调度器shutdown被调⽤时等待当前被调度的任务完成taskExecutor.setWaitForTasksToCompleteOnShutdown(true);// 等待时长taskExecutor.setAwaitTerminationSeconds(60);taskExecutor.initialize();return taskExecutor;}}其中的corePoolSize设置参考：N为cpu个数如果是CPU密集型应⽤，则线程池⼤⼩设置为N+1如果是IO密集型应⽤，则线程池⼤⼩设置为2N+1cpu个数查询⽅式：Runtime.getRuntime().availableProcessors()；linux查询⽅式：cat /proc/cpuinfo| grep"processor"| wc -l使⽤线程池实现异步import io.swagger.annotations.Api;import io.swagger.annotations.ApiOperation;import lombok.extern.slf4j.Slf4j;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.web.bind.annotation.GetMapping;import org.springframework.web.bind.annotation.RestController;import javax.annotation.Resource;import java.util.concurrent.Executor;/*** 使⽤demo* @author lipeiguang*/@Slf4j@Api(tags = {"异步线程测试"})@RestControllerpublic class ExecutorDemo {//使⽤时通过注解/*** 如果是多线程，可以直接使⽤这个executor*/@Resource(name = TaskExecutorConstant.SALARY_TASK_EXECUTOR) private Executor executor;@Autowiredprivate ServiceDemo serviceDemo;@ApiOperation("异步测试")@GetMapping("/test/async")public String testAsync(){("主线程开始执⾏。

JAVA自定义线程池的最大线程数设置方法

JAVA自定义线程池的最大线程数设置方法一、Java自定义线程池的作用线程池是一个减少在应用程序中创建和销毁线程的机制，它可以对线程进行重用，使线程池可以解决多线程同步的问题，提高程序服务能力，减少资源消耗，提高程序效率。

二、Java自定义线程池的原理创建线程池时，它会先创建固定数量的线程（拒绝政策），并将它们放入空闲队列中，当有任务需要处理时，会从队列中取出一个空闲线程来处理，有可能是一个新线程也可能是一个已存在的线程，比如，如果空闲队列中还有可用的线程，就会重新使用这些线程，而不会重新创建新的线程；如果空闲队列为空，则会创建新的线程来处理任务。

当一个线程处理完任务后，它会被重新放入空闲队列等待下一次处理任务。

如果空闲队列中线程数量超过了最大线程数，则这些空闲线程会被终止。

三、自定义线程池的最大线程数设置1.通过ThreadPoolExecutor.Builder类中的maximumPoolSize方法来设置最大线程数ThreadPoolExecutor.Builder builder = new ThreadPoolExecutor.Builder(;builder.maximumPoolSize(maxThreads);2.通过ThreadPoolExecutor类中的setMaximumPoolSize方法来设置最大线程数ThreadPoolExecutor executor = new ThreadPoolExecutor(; executor.setMaximumPoolSize(maxThreads);3.通过Executors类下的有参方法来设置最大线程数Executors.newFixedThreadPool(maxThreads);4.通过自定义ThreadPoolExecutor类来设置最大线程数public class MyThreadPoolExecutor extends ThreadPoolExecutor private int maxThreads;。

Java线程池创建的四种方式

Java线程池创建的四种⽅式闲话少叙...package com.adao.thread;import java.util.Calendar;import java.util.Date;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.ScheduledExecutorService;import java.util.concurrent.TimeUnit;public class ThreadPool {/*** 1.创建⼀个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若⽆可回收，则新建线程*/public static void cachedThreadPool() {ExecutorService cachedThreadPool = Executors.newCachedThreadPool();for (int j = 0; j < 10; j++) {for (int i = 0; i < 10; i++) {final int index = i;// try {// Thread.sleep(1000);// } catch (InterruptedException e) {// e.printStackTrace();// }cachedThreadPool.execute(new Runnable() {@Overridepublic void run() {System.out.println(index + "--" + Thread.currentThread().getId() + " name:"+ Thread.currentThread().getName());}});}}}/*** 2.创建⼀个定长线程池，可控制线程最⼤并发数，超出的线程会在队列中等待*/public static void newFixedThreadPool() {ExecutorService fixedThreadPool = Executors.newFixedThreadPool(5);for (int j = 0; j < 10; j++) {for (int i = 0; i < 10; i++) {final int index = i;fixedThreadPool.execute(new Runnable() {@Overridepublic void run() {try {System.out.println(index + "----" + Thread.currentThread().getId() + " name:"+ Thread.currentThread().getName());Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}}});}}// 两种关闭⽅式// fixedThreadPool.shutdown(); //不会⽴即终⽌线程池，⽽是要等所有任务缓存队列中的任务都执⾏完后才终⽌，但再也不会接受新的任务// fixedThreadPool.shutdownNow(); //⽴即终⽌线程池，并尝试打断正在执⾏的任务，并且清空任务缓存队列，返回尚未执⾏的任务}/*** 3.创建⼀个定长线程池，⽀持定时及周期性任务执⾏*/public static void newScheduledThreadPool() {ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(50);Calendar calendar = Calendar.getInstance();calendar.set(Calendar.HOUR_OF_DAY, 10); // 时calendar.set(Calendar.MINUTE, 53);// 分calendar.set(Calendar.SECOND, 00); // 秒// 计算现在时间和计划任务执⾏时间差多久，单位毫秒Long date = calendar.getTime().getTime() - System.currentTimeMillis();////延迟3秒执⾏scheduledThreadPool.schedule(new Runnable() {@Overridepublic void run() {System.out.println("delay 3 seconds--" + new Date().toLocaleString() + " name:"+ Thread.currentThread().getName());}}, 3, TimeUnit.SECONDS);// 延迟5秒执⾏，然后每隔2秒执⾏⼀次scheduledThreadPool.scheduleAtFixedRate(new Runnable() {@Overridepublic void run() {System.out.println("延迟5秒执⾏，然后每隔2秒执⾏⼀次--" + new Date().toLocaleString() + " name:"+ Thread.currentThread().getName());}}, 5, 2, TimeUnit.SECONDS);// 定时在某⼀时刻执⾏任务，然后间隔执⾏,如果时间过了会⽴马执⾏scheduledThreadPool.scheduleAtFixedRate(new Runnable() {@Overridepublic void run() {System.out.println("定时在某⼀时刻执⾏任务，然后间隔执⾏--" + new Date().toLocaleString() + " name:"+ Thread.currentThread().getName());}}, date / 1000, 2, TimeUnit.SECONDS);}/*** 4. 创建⼀个单线程化的线程池，它只会⽤唯⼀的⼯作线程来执⾏任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执⾏ */public static void newSingleThreadExecutor() {ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();for (int i = 0; i < 10; i++) {final int index = i;singleThreadExecutor.execute(new Runnable() {@Overridepublic void run() {try {System.out.println("单线程执⾏任务。

Java线程池使用和常用参数

Java线程池使⽤和常⽤参数多线程问题：1、java中为什么要使⽤多线程使⽤多线程，可以把⼀些⼤任务分解成多个⼩任务来执⾏，多个⼩任务之间互不影像，同时进⾏，这样，充分利⽤了cpu资源。

2、java中简单的实现多线程的⽅式继承Thread类，重写run⽅法;12 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 28class MyTread extends Thread{public void run() { System.out.println(Thread.currentThread().getName());}}实现Runable接⼝，实现run⽅法；class MyRunnable implements Runnable{ public void run() { System.out.println(Thread.currentThread().getName()); }}class ThreadTest { public static void main(String[] args) { MyTread thread = new Mythread(); thread.start(); //开启⼀个线程 MyRunnable myRunnable = new MyRunnable(); Thread runnable = new Thread(myRunnable); runnable.start(); //开启⼀个线程 }}3、java线程的状态创建：当new了⼀个线程，并没有调⽤start之前，线程处于创建状态；就绪：当调⽤了start之后，线程处于就绪状态，这是，线程调度程序还没有设置执⾏当前线程；运⾏：线程调度程序执⾏到线程时，当前线程从就绪状态转成运⾏状态，开始执⾏run⽅法⾥边的代码；阻塞：线程在运⾏的时候，被暂停执⾏（通常等待某项资源就绪后在执⾏，sleep、wait可以导致线程阻塞），这是该线程处于阻塞状态；死亡：当⼀个线程执⾏完run⽅法⾥边的代码或调⽤了stop⽅法后，该线程结束运⾏4、为什么要引⼊线程池当我们需要的并发执⾏线程数量很多时，且每个线程执⾏很短的时间就结束了，这样，我们频繁的创建、销毁线程就⼤⼤降低了⼯作效率（创建和销毁线程需要时间、资源）。

java 获取线程池状态方法

java 获取线程池状态方法线程池是Java多线程编程中常用的工具，它可以管理和重用线程，提高程序的性能和可靠性。

然而，了解线程池的状态是开发人员必备的技能。

本文将详细介绍Java中获取线程池状态的方法，帮助读者全面了解线程池的运行情况，提供有指导意义的指导。

要获取线程池的状态，首先需要创建一个线程池对象。

我们通常使用`ThreadPoolExecutor`类来创建线程池，该类提供了丰富的方法来操作和管理线程池。

以下是创建线程池的示例代码：```javaExecutorService executor =Executors.newFixedThreadPool(5);```在这个示例中，我们创建了一个固定大小的线程池，最多可以同时执行5个任务。

接下来，我们将介绍几种常用的方法来获取线程池的状态。

1. 获取线程池的活动线程数要获取线程池中当前活动线程的数量，我们可以使用`getActiveCount()`方法。

这个数值表示当前正在执行任务的线程数量。

示例代码如下：```javaint activeThreads = ((ThreadPoolExecutor)executor).getActiveCount();System.out.println("当前活动线程数：" + activeThreads);```2. 获取线程池的任务完成数线程池中的任务可以通过`submit()`方法提交到线程池中执行。

要获取线程池中已经完成的任务数量，我们可以使用`getCompletedTaskCount()`方法。

示例代码如下：```javalong completedTasks = ((ThreadPoolExecutor) executor).getCompletedTaskCount();System.out.println("已完成任务数：" + completedTasks);```3. 获取线程池的任务总数线程池的任务总数包括正在执行的任务和已经完成的任务。

java创建线程池的三种方法

java创建线程池的三种方法一、使用ThreadPoolExecutor类创建线程池ThreadPoolExecutor是Java提供的一个线程池实现类，通过它可以方便地创建一个线程池。

ThreadPoolExecutor提供了丰富的参数和方法来满足不同的需求。

创建ThreadPoolExecutor的方式一般有两种，一种是直接创建ThreadPoolExecutor的实例，另一种是通过Executors工厂类提供的静态方法来创建。

1. 直接创建ThreadPoolExecutor实例可以通过构造函数来创建ThreadPoolExecutor实例，构造函数的参数包括核心线程数、最大线程数、线程空闲时间、任务队列等。

示例代码如下：```javaThreadPoolExecutor executor = new ThreadPoolExecutor(corePoolSize, // 核心线程数maximumPoolSize, // 最大线程数keepAliveTime, // 线程空闲时间TimeUnit.SECONDS, // 时间单位workQueue // 任务队列);```2. 使用Executors工厂类创建ThreadPoolExecutor实例Executors工厂类提供了一些静态方法来创建ThreadPoolExecutor 实例，比如newFixedThreadPool、newCachedThreadPool等。

示例代码如下：```javaExecutorService executor = Executors.newFixedThreadPool(nThreads); // 创建固定大小的线程池ExecutorService executor = Executors.newCachedThreadPool(); // 创建可缓存的线程池```二、使用ScheduledThreadPoolExecutor类创建定时线程池ScheduledThreadPoolExecutor是ThreadPoolExecutor的子类，它专门用于创建定时线程池。

java 线程池参数

java 线程池参数摘要：1.Java 线程池简介2.Java 线程池的参数3.参数详解3.1.核心线程数3.2.最大线程数3.3.队列容量3.4.时间参数3.5.拒绝策略4.参数设置建议正文：【Java 线程池简介】Java 线程池（ExecutorService）是Java 并发编程中的一个重要工具，它允许程序控制线程的创建、管理和调度。

通过使用线程池，可以避免手动创建和管理线程带来的复杂性和资源浪费，提高程序的运行效率和稳定性。

【Java 线程池的参数】在创建线程池时，需要配置一系列参数，这些参数决定了线程池的运行行为和性能。

下面我们将详细介绍这些参数。

【参数详解】1.核心线程数（corePoolSize）：线程池中始终存在的线程数量。

当线程池创建后，这些线程将被立即初始化，即使它们没有被任务使用。

如果任务数量超过核心线程数，线程池将创建新的线程来处理这些任务。

默认值为0，表示线程池中不保留任何空闲线程。

2.最大线程数（maxPoolSize）：线程池中允许存在的最大线程数量。

当任务数量超过核心线程数且队列已满时，线程池将创建新的线程来处理这些任务，但线程数量不会超过这个参数的值。

默认值为Integer.MAX_VALUE，表示线程池允许无限制地创建线程。

3.队列容量（queueCapacity）：线程池中的任务队列可以容纳的最大任务数量。

当线程池中的线程数量达到最大值且队列已满时，新的任务将无法加入队列，直到队列中有空闲空间。

默认值为10，表示队列容量为10。

4.时间参数（keepAliveTime，timeUnit）：线程池中空闲线程的存活时间。

当线程池中的任务数量少于核心线程数时，空闲线程将等待任务，最多等待的时间由这个参数决定。

默认值为60 秒，时间单位为秒（SECONDS）。

5.拒绝策略（rejectedExecutionHandler）：当线程池无法处理任务时，可以采取的策略。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

线程池的作用:线程池作用就是限制系统中执行线程的数量。

根据系统的环境情况，可以自动或手动设置线程数量，达到运行的最佳效果；少了浪费了系统资源，多了造成系统拥挤效率不高。

用线程池控制线程数量，其他线程排队等候。

一个任务执行完毕，再从队列的中取最前面的任务开始执行。

若队列中没有等待进程，线程池的这一资源处于等待。

当一个新任务需要运行时，如果线程池中有等待的工作线程，就可以开始运行了；否则进入等待队列。

为什么要用线程池:1.减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务2.可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为因为消耗过多的内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)线程池类Java代码1.package com.tdt.impl.ls;2.3.import java.util.LinkedList;4.5./**6. * @project LocationGateway7. * @author sunnylocus8. * @verson 1.0.09. * @date Aug 2, 200810. * @jdk 1.4.211. */12.public class ThreadPool extends ThreadGroup {13. private boolean isClosed = false; //线程池是否关闭14. private LinkedList workQueue; //工作队列15. private static int threadPoolID = 1; //线程池的id16. public ThreadPool(int poolSize) { //poolSize 表示线程池中的工作线程的数量17.18. super(threadPoolID + ""); //指定ThreadGroup的名称19. setDaemon(true); //继承到的方法，设置是否守护线程池20. workQueue = new LinkedList(); //创建工作队列21. for(int i = 0; i < poolSize; i++) {22. new WorkThread(i).start(); //创建并启动工作线程,线程池数量是多少就创建多少个工作线程23. }24. }25.26. /** 向工作队列中加入一个新任务,由工作线程去执行该任务*/27. public synchronized void execute(Runnable task) {28. if(isClosed) {29. throw new IllegalStateException();30. }31. if(task != null) {32. workQueue.add(task);//向队列中加入一个任务33. notify(); //唤醒一个正在getTask()方法中待任务的工作线程34. }35. }36.37. /** 从工作队列中取出一个任务,工作线程会调用此方法*/38. private synchronized Runnable getTask(int threadid) throwsInterruptedException {39. while(workQueue.size() == 0) {40. if(isClosed) return null;41. System.out.println("工作线程"+threadid+"等待任务...");42. wait(); //如果工作队列中没有任务,就等待任务43. }44. System.out.println("工作线程"+threadid+"开始执行任务...");45. return (Runnable) workQueue.removeFirst(); //反回队列中第一个元素,并从队列中删除46. }47.48. /** 关闭线程池 */49. public synchronized void closePool() {50. if(! isClosed) {51. waitFinish(); //等待工作线程执行完毕52. isClosed = true;53. workQueue.clear(); //清空工作队列54. interrupt(); //中断线程池中的所有的工作线程,此方法继承自ThreadGroup类55. }56. }57.58. /** 等待工作线程把所有任务执行完毕*/59. public void waitFinish() {60. synchronized (this) {61. isClosed = true;62. notifyAll(); //唤醒所有还在getTask()方法中等待任务的工作线程63. }64. Thread[] threads = new Thread[activeCount()]; //activeCount() 返回该线程组中活动线程的估计值。

65. int count = enumerate(threads); //enumerate()方法继承自ThreadGroup类，根据活动线程的估计值获得线程组中当前所有活动的工作线程66. for(int i =0; i < count; i++) { //等待所有工作线程结束67. try {68. threads[i].join(); //等待工作线程结束69. }catch(InterruptedException ex) {70. ex.printStackTrace();71. }72. }73. }74.75. /**76. * 内部类,工作线程,负责从工作队列中取出任务,并执行77. * @author sunnylocus78. */79. private class WorkThread extends Thread {80. private int id;81. public WorkThread(int id) {82. //父类构造方法,将线程加入到当前ThreadPool线程组中83. super(ThreadPool.this,id+"");84. this.id =id;85. }86. public void run() {87. while(! isInterrupted()) { //isInterrupted()方法继承自Thread类，判断线程是否被中断88. Runnable task = null;89. try {90. task = getTask(id); //取出任务91. }catch(InterruptedException ex) {92. ex.printStackTrace();93. }94. //如果getTask()返回null或者线程执行getTask()时被中断，则结束此线程95. if(task == null) return;96.97. try {98. task.run(); //运行任务99. }catch(Throwable t) {100. t.printStackTrace();101. }102. }// end while103. }// end run104. }// end workThread105.}2.测试类Java代码1.package com.tdt.test;2.3.import com.tdt.impl.ls.ThreadPool;4.5.public class ThreadPoolTest {6.7. public static void main(String[] args) throws InterruptedException {8. ThreadPool threadPool = new ThreadPool(3); //创建一个有个3工作线程的线程池9. Thread.sleep(500); //休眠500毫秒,以便让线程池中的工作线程全部运行10. //运行任务11. for (int i = 0; i <=5 ; i++) { //创建6个任务12. threadPool.execute(createTask(i));13. }14. threadPool.waitFinish(); //等待所有任务执行完毕15. threadPool.closePool(); //关闭线程池16.17. }18.19. private static Runnable createTask(final int taskID) {20. return new Runnable() {21. public void run() {22. // System.out.println("Task" + taskID + "开始");23. System.out.println("Hello world");24. // System.out.println("Task" + taskID + "结束");25. }26. };27. }28.}结果:Java代码1.工作线程0等待任务...2.工作线程1等待任务...3.工作线程2等待任务...4.5.工作线程0开始执行任务...6.Hello world7.工作线程0等待任务...8.9.工作线程1开始执行任务...10.Hello world11.工作线程1等待任务...12.13.工作线程2开始执行任务...14.Hello world15.工作线程2等待任务...16.17.工作线程0开始执行任务...18.Hello world19.工作线程0等待任务...20.21.工作线程1开始执行任务...22.Hello world23.工作线程1等待任务...24.25.工作线程2开始执行任务...26.Hello world27.工作线程2等待任务...。