Java中的线程池

最新推荐文章于 2025-04-17 11:04:06 发布

芋头小伙

最新推荐文章于 2025-04-17 11:04:06 发布

阅读量147

点赞数

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

本文链接：https://blog.youkuaiyun.com/weixin_43521932/article/details/108349432

版权

java 专栏收录该内容

1 篇文章

订阅专栏

Java中的线程池

1、简介

传统多线程带来的问题：

多线程运行，系统不断的启动和关闭新线程，会过度消耗系统系统

过度切换线程会增加危险性，从而可能导致系统资源的奔溃

解决方法

池化技术

不直接创建具体的资源，而是创建一个池，在池里面创建具体的资源。以前是直接把任务交给具体的资源，而现在是直接把资源交给池，池就会让空闲的资源去执行任务，任务执行完了以后，资源并不会销毁，而是停留在池里面，等待下一个任务来执行

线程池的好处：

降低系统资源消耗，通过重用已存在的线程，降低线程创建和销毁造成的消耗

方便线程并发数的管控

提供更强大的功能，延时定时线程池

2、工作原理

在线程池的编程模式下，任务是提交给整个线程池的，而不是直接提交给某个线程，线程池在拿到任务后，就在内部寻找是否有空闲的线程，如果有，则将任务交给某个空闲的线程。
在这里插入图片描述

一个线程同时只能执行一个任务，但可以同时向一个线程池提交多个任务
在这里插入图片描述

线程池工作的本质就是将要执行的任务添加到队列中，然后线程池寻求空闲的线程来执行队列里面的任务。

3、线程池介绍

3.1 工作队列

通过上面的例子知道线程池都是将要执行的任务存放在工作队列中，然后在线程池里面寻找空闲的线程去执行里面的任务。java中主要采用BlockingQueue去存储任务

3.2.1BlockingQueue

双缓冲队列，内部使用两条队列，允许两个线程同时向队列一个存储，一个去处操作。在保证并发安全的同时，提高了队列的存取效率。

在这里插入图片描述

通过其源码可知，该阻塞队列继承了Queue队列遵循先进先出原则(FIFO)

队列提供几种基本的操作：

添加元素（队尾）
移除元素（队头）
取出对头元素（不移除）

每种操作都有两个方法，一种有可能抛出异常，一种返回操作成功或失败

3.2.2 ArrayBlockingQueue

采用数组实现，规定大小的BlockingQueue，其构造必须指定大小，其所含的对象时FIFO顺序排序的

在这里插入图片描述

3.2.3 LinkedBlockingQueue

采用双向链表实现，大小不固定，若其构造器指定大小，生成的BlockingQueue有大小限制，不指定大小，其大小由Integer.MAX_VALUE来决定。其所含的对象是FIFO顺序排序的

在这里插入图片描述

3.2.4 PriorityBlockingQueue

类似于LinkedBlockingQueue，但是其所含对象的排序不是FIFO，而是依据对象的自然排序或者构造函数的Comparator决定。

在这里插入图片描述

3.2.5 SynchronousQueue

特殊的BlockingQueue

每次删除操作都要等待插入操作

每次插入操作都要等待删除操作

一个元素，一旦有了插入线程和移除线程，那么很快由插入线程移交给移除线程，这个容器相当于通道，本身不存储元素。

在多任务队列，是最快的处理任务方式

在这里插入图片描述

3.3 创建线程池

java中使用了ThreadPoolExecutor来表示线程池，创建该类对象来表示创建一个线程池

/*
		 *   corePoolSize 核心线程数
		 *    maximumPoolSize  最大线程数
		 *    keepAliveTime  线程池除了核心线程之外的其他线程最长可以存活的时间
		 *    unit  计算这个时间的单位
		 *    workQueue 就是等待队列，任务可以存储在任务队列中等待被执行
		 * 
		 * */
		ThreadPoolExecutor executor = new ThreadPoolExecutor(2,6, 2,
				TimeUnit.SECONDS,
				new SynchronousQueue<Runnable>() );

corePoolSize 核心线程数量，这几个核心线程，在没有使用的时候也不会被回收

maximumPoolSize 就是线程池中可以容纳的最大线程的数量

keepAliveTime，就是线程池中除了核心线程之外的其他线程的最长可以存活的时间，线程池中，除了核心线程即使在无任务的情况下也不能被清除，其余的都是有存活时间的

util，就是计算这个时间的单位

workQueue 任务可以存储在任务队列中等待被执行

3.4 使用线程池

package com.hzx.test;

import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class ThreadPoolTest {
	public static void main(String[] args) {
		/*
		 *   corePoolSize 核心线程数
		 *    maximumPoolSize  最大线程数
		 *    keepAliveTime  线程池除了核心线程之外的其他线程最长可以存活的时间
		 *    unit  计算这个时间的单位
		 *    workQueue 就是等待队列，任务可以存储在任务队列中等待被执行
		 * 
		 * */
		ThreadPoolExecutor executor = new ThreadPoolExecutor(2,6, 2,
				TimeUnit.SECONDS,
				new SynchronousQueue<Runnable>() );
		//提交任务去执行
		Runnable t1 = ()->{
			try {
				Thread.sleep(5000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName());
		};
		
		Runnable t2 = ()->{
			System.out.println(Thread.currentThread().getName());
		};
		
		Runnable t3 = ()->{
			System.out.println(Thread.currentThread().getName());
		};
		
		Runnable t4 = ()->{
			System.out.println(Thread.currentThread().getName());
		};
		
		
		//任务执行完毕，JVM并不会关闭，因为里面的核心线程没有结束掉
		executor.execute(t1);
		executor.execute(t2);
		executor.execute(t3);
		executor.execute(t4);
		
		//关闭线程池  等到里面所有的线程空闲了才会关闭
		//如果有线程正在执行那么就等执行完毕再关闭
		executor.shutdown();
		
		
	}

}

3.5 常用线程池

Java通过Executor提供四中线程池：

newCacheThreadPool

创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程

newFixedThreadPool

创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待

newScheduledThreadPool

创建一个定长线程池，支持定时及周期性任务执行

newSingleThreadExecutor

创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序（FIFO、LIFO、优先级）执行

3.5.1 newCacheThreadPool

创建一个课缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程

在这里插入图片描述

通过上述源码可知，创建的都是非核心线程，最大线程数为Integer.MAX_VALUE，空闲线程存活时间是60秒。

该线程运行时先查看池中有没有以前建立的线程，如果有，就直接使用。如果没有，就创建一个新的线程加入池中，缓存型池子通常用于执行一些生存期很短的异步型任务。

使用如下：

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

public class NewCacheThreadPoolTest {
	public static void main(String[] args) throws InterruptedException {
		//重复使用线程，一旦线程空闲就不创建新的线程
		//而是使用上一次任务遗留的线程去执行
		//能不创建就不创建，只有迫不得已才会创建
		//最多创建0x7ffffff
		ExecutorService exe=Executors.newCachedThreadPool();
		for(int i=0;i<10;i++) {
			Thread.sleep(1000);
			exe.execute(new Runnable() {
				
				@Override
				public void run() {
					// TODO Auto-generated method stub
					
					System.out.println(Thread.currentThread().getName()+": ");
				}
			});
		}
	}

}
/*
执行结果
pool-1-thread-1: 
pool-1-thread-1: 
pool-1-thread-1: 
pool-1-thread-1: 
pool-1-thread-1: 
pool-1-thread-1: 
pool-1-thread-1: 
pool-1-thread-1: 
pool-1-thread-1: 
pool-1-thread-1: 
*/

3.5.2 newFixedThreadPool

创建一个定长线程池，可控制线程最大并大数，超出的线程会在队列中等待

在这里插入图片描述

通过源码可知，核心线程数和最大线程数一样，且空闲线程存活时间为0L，使用LinkedBlockQueue

使用如下：

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

public class NewFixedThreadPoolTest {
	public static void main(String[] args) throws InterruptedException {
		//线程池一旦创建就会创建执行size的核心线程
		//jvm不会关闭
		//查询电脑内核线程数
		//System.out.println(Runtime.getRuntime().availableProcessors());
		ExecutorService exe= Executors.newFixedThreadPool(5);
		for(int i=0;i<10;i++) {
			Thread.sleep(2000);
			exe.execute(new Runnable() {
				
				@Override
				public void run() {
					// TODO Auto-generated method stub
					System.out.println(Thread.currentThread().getName());
				}
			});
		}
	}
}

/*执行结果
pool-1-thread-1
pool-1-thread-2
pool-1-thread-3
pool-1-thread-4
pool-1-thread-5
pool-1-thread-1
pool-1-thread-2
pool-1-thread-3
pool-1-thread-4
pool-1-thread-5
*/

如果队列里面有线程任务的话就从队列里面取出线程，然后开启一个新的线程开始执行。如果没有就会进行等待，有空闲线程再使用。这个线程池始终只有size的线程在运行，大小固定，难以扩展

所以定义线程时最好是根据线程池大小需要根据资源配置进行设置：Runtime.getRuntime().availableProcessors()

3.5.3 newSingleThreadExecutor()

创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO、LIFO、优先级）执行

在这里插入图片描述

通过源码可知，该线程只创建了一个核心线程，且最大线程数为1，空闲线程存活时间为0L，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序执行。

使用如下：

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

public class NewSingleThreadPoolTest {
	public static void main(String[] args) {
		ExecutorService exe= Executors.newSingleThreadExecutor();
		for(int i=0;i<20;i++) {
			exe.execute(new Runnable() {
				@Override
				public void run() {
					// TODO Auto-generated method stub
					System.out.println(Thread.currentThread().getName());
				}
			});
		}
	}

}
/*执行结果：
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1*/

3.5.4 newScheduleThreadPool（）

定长线程池，支持定时及周期性任务执行，一般我们也使用该线程池来做定时任务调度

在这里插入图片描述

其中的super类为：

在这里插入图片描述

通过源码可知，创建的是ScheduledThreadPoolExecutor，返回ScheduledExecutorService对象，用法如下：

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

public class NewScheduledThreadPoolTest {
	public static void main(String[] args) {
		//还增加了延迟执行和周期执行的
		ScheduledExecutorService exe=Executors.newScheduledThreadPool(5);
		
			
		//延迟执行
		exe.schedule(new Runnable() {
			
			@Override
			public void run() {
				// TODO Auto-generated method stub
				System.out.println(Thread.currentThread().getName());
			}
		}, 3, TimeUnit.SECONDS);
		
		//周期性执行
		//延迟1s执行，之后每隔2s执行一次
		exe.scheduleAtFixedRate(new Runnable() {
			
			@Override
			public void run() {
				// TODO Auto-generated method stub
				System.out.println(Thread.currentThread().getName());
			}
		}, 1, 2, TimeUnit.SECONDS);
	}

}