Java常用线程池原理及使用方法解析

2023-07-19 13:14:05 58

一、简介

什么是线程池？

池的概念大家也许都有所听闻，池就是相当于一个容器，里面有许许多多的东西你可以即拿即用。java中有线程池、连接池等等。线程池就是在系统启动或者实例化池时创建一些空闲的线程，等待工作调度，执行完任务后，线程并不会立即被销毁，而是重新处于空闲状态，等待下一次调度。

线程池的工作机制？

在线程池的编程模式中，任务提交并不是直接提交给线程，而是提交给池。线程池在拿到任务之后，就会寻找有没有空闲的线程，有则分配给空闲线程执行，暂时没有则会进入等待队列，继续等待空闲线程。如果超出最大接受的工作数量，则会触发线程池的拒绝策略。

为什么使用线程池？

线程的创建与销毁需要消耗大量资源，重复的创建与销毁明显不必要。而且池的好处就是响应快，需要的时候自取，就不会存在等待创建的时间。线程池可以很好地管理系统内部的线程，如数量以及调度。

二、常用线程池介绍

Java类ExecutorService是线程池的父接口，并非顶层接口。以下四种常用线程池的类型都可以是ExecutorService。

单一线程池Executors.newSingleThreadExecutor()
内部只有唯一一个线程进行工作调度，可以保证任务的执行顺序（FIFO,LIFO）

packagecom.test;

importjava.util.ArrayList;
importjava.util.List;
importjava.util.concurrent.ExecutorService;
importjava.util.concurrent.Executors;

publicclassPoolTest{
	publicstaticvoidmain(String[]args){
		//创建单一线程池
		ExecutorServicesingleThreadExecutor=Executors.newSingleThreadExecutor();
		Listlist=newArrayList();
		list.add("first");
		list.add("second");
		list.add("third");
		list.forEach(o->{
			//遍历集合提交任务
			singleThreadExecutor.execute(newRunnable(){

				@Override
				publicvoidrun(){
					System.out.println(Thread.currentThread().getName()+":"+o);
					try{
						//间隔1s
						Thread.sleep(1000);
					}catch(InterruptedExceptione){
						e.printStackTrace();
					}
				}
			});
		});
	}
}

执行结果：

pool-1-thread-1:first

pool-1-thread-1:second

pool-1-thread-1:third

可缓存线程池Executors.newCachedThreadPool()

如果线程池中有可使用的线程，则使用，如果没有，则在池中新建一个线程，可缓存线程池中线程数量最大为Integer.MAX_VALUE。通常用它来运行一些执行时间短，且经常用到的任务。

packagecom.test;

importjava.util.ArrayList;
importjava.util.List;
importjava.util.concurrent.ExecutorService;
importjava.util.concurrent.Executors;

publicclassPoolTest{
	publicstaticvoidmain(String[]args){
		//创建可缓存线程池
		ExecutorServicecachedThreadPool=Executors.newCachedThreadPool();
		Listlist=newArrayList();
		list.add("first");
		list.add("second");
		list.add("third");
		list.forEach(o->{

			try{
				//间隔3s
				Thread.sleep(3000);
			}catch(InterruptedExceptione){
				e.printStackTrace();
			}

			//遍历集合提交任务
			cachedThreadPool.execute(newRunnable(){

				@Override
				publicvoidrun(){
					System.out.println(Thread.currentThread().getName()+":"+o);
					try{
						//间隔1s
						Thread.sleep(1000);
					}catch(InterruptedExceptione){
						e.printStackTrace();
					}
				}
			});
		});
	}
}

执行结果：

pool-1-thread-1:first

pool-1-thread-1:second

pool-1-thread-1:third

因为间隔时间长，下一个任务运行时，上一个任务已经完成，所以线程可以继续复用，如果间隔时间调短，那么部分线程将会使用新线程来运行。

把每个任务等待时间从3s调低至1s:

执行结果：

pool-1-thread-1:first

pool-1-thread-2:second

pool-1-thread-1:third

定长线程池Executors.newFixedThreadPool(intnThreads)
创建一个固定线程数量的线程池，参数手动传入

packagecom.test;

importjava.util.ArrayList;
importjava.util.List;
importjava.util.concurrent.ExecutorService;
importjava.util.concurrent.Executors;

publicclassPoolTest{
	publicstaticvoidmain(String[]args){
		//创建可缓存线程池
		ExecutorServicefixedThreadPool=Executors.newFixedThreadPool(3);
		Listlist=newArrayList();
		list.add("first");
		list.add("second");
		list.add("third");
		list.add("fourth");
		list.forEach(o->{

			try{
				//间隔1s
				Thread.sleep(1000);
			}catch(InterruptedExceptione){
				e.printStackTrace();
			}

			//遍历集合提交任务
			fixedThreadPool.execute(newRunnable(){

				@Override
				publicvoidrun(){
					System.out.println(Thread.currentThread().getName()+":"+o);
					try{
						//间隔1s
						Thread.sleep(1000);
					}catch(InterruptedExceptione){
						e.printStackTrace();
					}
				}
			});
		});
	}
}

执行结果：

pool-1-thread-1:first

pool-1-thread-2:second

pool-1-thread-3:third

pool-1-thread-1:fourth

定时线程池Executors.newScheduledThreadPool(intcorePoolSize)
创建一个定长线程池，支持定时及周期性任务执行

packagecom.test;

importjava.util.concurrent.Executors;
importjava.util.concurrent.ScheduledExecutorService;
importjava.util.concurrent.TimeUnit;

publicclassPoolTest{
	publicstaticvoidmain(String[]args){
		//创建定长线程池、支持定时、延迟、周期性执行任务
		ScheduledExecutorServicescheduledThreadPool=Executors.newScheduledThreadPool(3);
		scheduledThreadPool.scheduleAtFixedRate(newRunnable(){

			@Override
			publicvoidrun(){
				System.out.println(Thread.currentThread().getName()+":1秒后每隔3秒执行一次");
			}
		},1,3,TimeUnit.SECONDS);
	}
}

执行结果：

pool-1-thread-1:1秒后每隔3秒执行一次

pool-1-thread-1:1秒后每隔3秒执行一次

pool-1-thread-2:1秒后每隔3秒执行一次

pool-1-thread-2:1秒后每隔3秒执行一次

pool-1-thread-2:1秒后每隔3秒执行一次

pool-1-thread-2:1秒后每隔3秒执行一次

pool-1-thread-2:1秒后每隔3秒执行一次

三、自定义线程池

常用构造函数：

ThreadPoolExecutor(intcorePoolSize,intmaximumPoolSize,longkeepAliveTime,TimeUnitunit,BlockingQueueworkQueue)

参数说明：

1、corePoolSize核心线程数大小，当线程数

2、maximumPoolSize最大线程数，当线程数>=corePoolSize的时候，会把runnable放入workQueue中

3、keepAliveTime保持存活时间，当线程数大于corePoolSize的空闲线程能保持的最大时间。

4、unit时间单位

5、workQueue保存任务的阻塞队列

6、threadFactory创建线程的工厂

7、handler拒绝策略

任务执行顺序：

1、当线程数小于corePoolSize时，创建线程执行任务。

2、当线程数大于等于corePoolSize并且workQueue没有满时，放入workQueue中

3、线程数大于等于corePoolSize并且当workQueue满时，新任务新建线程运行，线程总数要小于maximumPoolSize

4、当线程总数等于maximumPoolSize并且workQueue满了的时候执行handler的rejectedExecution。也就是拒绝策略。

ThreadPoolExecutor默认有四个拒绝策略：

1、newThreadPoolExecutor.AbortPolicy()直接抛出异常RejectedExecutionException

2、newThreadPoolExecutor.CallerRunsPolicy()直接调用run方法并且阻塞执行

3、newThreadPoolExecutor.DiscardPolicy()直接丢弃后来的任务

4、newThreadPoolExecutor.DiscardOldestPolicy()丢弃在队列中队首的任务

缓冲队列BlockingQueue：

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

常用的几种BlockingQueue：

ArrayBlockingQueue（inti）:规定大小的BlockingQueue，其构造必须指定大小。其所含的对象是FIFO顺序排序的。
LinkedBlockingQueue（）或者（inti）:大小不固定的BlockingQueue，若其构造时指定大小，生成的BlockingQueue有大小限制，不指定大小，其大小有Integer.MAX_VALUE来决定。其所含的对象是FIFO顺序排序的。
PriorityBlockingQueue（）或者（inti）:类似于LinkedBlockingQueue，但是其所含对象的排序不是FIFO，而是依据对象的自然顺序或者构造函数的Comparator决定。
SynchronizedQueue（）:特殊的BlockingQueue，对其的操作必须是放和取交替完成。

packagecom.test;

importjava.util.concurrent.LinkedBlockingDeque;
importjava.util.concurrent.RejectedExecutionHandler;
importjava.util.concurrent.ThreadPoolExecutor;
importjava.util.concurrent.TimeUnit;

publicclassPoolTest{
	publicstaticvoidmain(String[]args){
		//工作队列
		LinkedBlockingDequeworkQueue=newLinkedBlockingDeque();
		//拒绝策略
		RejectedExecutionHandlerhandler=newThreadPoolExecutor.AbortPolicy();
		ThreadPoolExecutorthreadPoolExecutor=newThreadPoolExecutor(2,10,20,TimeUnit.MILLISECONDS,workQueue,handler);
		threadPoolExecutor.execute(newRunnable(){

			@Override
			publicvoidrun(){
				System.out.println("自定义线程池");
			}
		});
	}
}

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持毛票票。

Java常用线程池原理及使用方法解析

热门推荐

随机推荐