4种常用线程池介绍

最新推荐文章于 2024-07-26 22:36:20 发布

疯狂撸代码的奋青

最新推荐文章于 2024-07-26 22:36:20 发布

阅读量586

点赞数

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

原文链接：https://blog.csdn.net/u013915286/article/details/103985438/

版权

多线程专栏收录该内容

10 篇文章 0 订阅

订阅专栏

文章目录

一. 线程池简介

线程池的概念：

线程池就是首先创建一些线程，它们的集合称为线程池。使用线程池可以很好地提高性能，线程池在系统启动时即创建大量空闲的线程，程序将一个任务传给线程池，线程池就会启动一条线程来执行这个任务，执行结束以后，该线程并不会死亡，而是再次返回线程池中成为空闲状态，等待执行下一个任务。

线程池的工作机制

在线程池的编程模式下，任务是提交给整个线程池，而不是直接提交给某个线程，线程池在拿到任务后，就在内部寻找是否有空闲的线程，如果有，则将任务交给某个空闲的线程。
一个线程同时只能执行一个任务，但可以同时向一个线程池提交多个任务。

使用线程池的原因：

多线程运行时间，系统不断的启动和关闭新线程，成本非常高，会过渡消耗系统资源，以及过渡切换线程的危险，从而可能导致系统资源的崩溃。这时，线程池就是最好的选择了。

二. 四种常见的线程池详解

线程池的返回值ExecutorService简介：

ExecutorService是Java提供的用于管理线程池的类。该类的两个作用：控制线程数量和重用线程

具体的4种常用的线程池实现如下：（返回值都是ExecutorService）

Executors.newCacheThreadPool()

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

示例代码：

package com.mianshi.test;

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

public class NewCachedThreadPoolTest {

    public static void main(String[] args) {
        // 创建一个可缓存线程池
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) {
            try {
                // sleep可明显看到使用的是线程池里面以前的线程，没有创建新的线程
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            cachedThreadPool.execute(new Runnable() {
                public void run() {
                    // 打印正在执行的缓存线程信息
                    System.out.println(Thread.currentThread().getName()
                            + "正在被执行");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }

}

输出结果：

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正在被执行

线程池为无限大，当执行当前任务时上一个任务已经完成，会复用执行上一个任务的线程，而不用每次新建线程

Executors.newFixedThreadPool(int n)

创建一个可重用固定个数的线程池，以共享的无界队列方式来运行这些线程。

示例代码：

package com.mianshi.test;

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

public class NewFixedThreadPoolTest {

    public static void main(String[] args) {
        // 创建一个可重用固定个数的线程池
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 10; i++) {
            fixedThreadPool.execute(new Runnable() {
                public void run() {
                    try {
                        // 打印正在执行的缓存线程信息
                        System.out.println(Thread.currentThread().getName()
                                + "正在被执行");
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }
}

输出结果：

pool-1-thread-1正在被执行
pool-1-thread-2正在被执行
pool-1-thread-3正在被执行
pool-1-thread-1正在被执行
pool-1-thread-2正在被执行
pool-1-thread-3正在被执行
pool-1-thread-1正在被执行
pool-1-thread-2正在被执行
pool-1-thread-3正在被执行
pool-1-thread-1正在被执行

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

Executors.newScheduledThreadPool(int n)

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

延迟执行示例代码：

package com.mianshi.test;

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 scheduledThreadPool = Executors.newScheduledThreadPool(5);
                 //延迟1秒执行
                 /*scheduledThreadPool.schedule(new Runnable() {
                     public void run() {
                        System.out.println("延迟1秒执行");
                     }
                 }, 1, TimeUnit.SECONDS);*/
                 
                 
                 //延迟1秒后每3秒执行一次
                 scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
                     public void run() {
                         System.out.println("延迟1秒后每3秒执行一次");
                     }
                }, 1, 3, TimeUnit.SECONDS);
                 
             }
}

输出结果：

延迟1秒后每3秒执行一次
延迟1秒后每3秒执行一次
.............

Executors.newSingleThreadExecutor()

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

示例代码：

public class NewSingleThreadPool {
public static void main(String[] args) {
	ExecutorService service=Executors.newSingleThreadExecutor();
	for (int i=0;i<5;i++) {
			service.execute(()->{
				try {
					TimeUnit.MILLISECONDS.sleep(500);
				} catch (Exception e) {
					// TODO: handle exception
				}
				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

ForkJoinPool是采用递归的方式来启动线程。

fork操作的作用是把一个大的问题划分成若干个较小的问题。在这个划分过程一般是递归进行的。直到可以直接进行计算。需要恰当地选取子问题的大小。太大的子问题不利于通过并行方式来提高性能，而太小的子问题则会带来较大的额外开销。每个子问题计算完成后，可以得到关于整个问题的部分解。join操作的作用是把这些分解手机组织起来，得到完整解。

简单的说，ForkJoin其核心思想就是分治。Fork分解任务，Join收集数据。详细请看API文档。
示例代码：求100000万个范围在0-100之间的随机数的和。采用了顺序和分治两种类型来运行。

package concurrent;

import java.io.IOException;
import java.util.Arrays;
import java.util.Random;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveAction;
import java.util.concurrent.RecursiveTask;
import java.util.concurrent.TimeUnit;

import jdk.dynalink.beans.StaticClass;

/**
*@author liuye
*@version 创建时间: 2020年1月31日 下午1:31:22
* 类说明
*/
public class ForkJoinPoolTest {

	static int[]nums=new int[1000000];
	static Random random=new Random();
	static final int MAX_NUM=50000;
//顺序执行时间
	static {
		int startTime=(int) System.currentTimeMillis();
		for (int i=0;i<nums.length;i++)
			nums[i]=random.nextInt(100);
	int endTime=(int) System.currentTimeMillis();
	System.out.println(endTime-startTime);
		System.out.println(Arrays.stream(nums).sum());
	}
	
	static class AddTask extends RecursiveTask<Long>{
		
		
		int start,end;
		public AddTask(int s,int e) {
			
			start=s;
			end=e;
			// TODO Auto-generated constructor stub
		}
		@Override
protected Long compute() {
	//递归进行
	if(end-start<=MAX_NUM) {
		long sum=0;
		for (int i=start;i<end;i++)
			sum+=nums[i];
		return sum;


	}else {
		int middle=start+(end-start)/2
				;
		//启动两个任务
		AddTask subTask1=new AddTask(start, middle);
		AddTask subTask2=new AddTask(middle, end);
		//分治进行
		subTask1.fork();
		subTask2.fork();
		//结果汇总
		return subTask1.join()+
		subTask2.join();
	}

}

	
	}
public static void main(String[] args) {
	int startTime=(int) System.currentTimeMillis();
	ForkJoinPool forkJoinPool=new ForkJoinPool();
	AddTask task=new AddTask(0, nums.length);
	forkJoinPool.execute(task);
	System.out.println(task.join());
	int endTime=(int) System.currentTimeMillis();
	System.out.println(endTime-startTime);
}
}

运行结果

运行结果：49522392
顺序执行运行时间：100
运行结果：49522392
采用firkJoin方式运行时间：17

ForkJoin主要提供了两个主要的执行任务的接口。RecurisiveAction与RecurisiveTask 。

RcurisiveAction ：没有返回值的接口。
RcurisiveTask ：带有返回值的接口。
fork/join框架任务的执行由ForkJoinTask类的对象之外，还可以使用一般的Callable和Runnable接口来表示任务。
ForkJoin要利用线程池ForkJoinPool。每个线程池都有一个WorkQueue实例。ForkJoinPool推荐查看JDK8的源码，比JDK7更利于理解。

在ForkJoinPool类的对象中执行的任务大支可以分为两类，一类通过execute、invoke或submit提交的任务；另一类是ForkJoinTask类的对象在执行过程中产生的子任务，并通过fork方法来运行。一般的做法是表示整个问题的ForkJoinTask类的对象用第一类型是提交，而在执行过程中产生的子任务并不需要进行处理，ForkJoinPool类对象会负责子任务的执行。

！！核心线程数与最大线程数的区别！！

当提交一个新任务到线程池时首先线程池判断基本线程池(corePoolSize)是否已满？
	没满，创建一个工作线程来执行任务。
	满了，则进入下个流程；
		其次线程池判断工作队列(workQueue)是否已满？
			没满，则将新提交的任务存储在工作队列里。
			满了，则进入下个流程；
				最后线程池判断整个线程池(maximumPoolSize)是否已满？
					没满，则创建一个新的工作线程来执行任务，
					满了，则交给饱和策略来处理这个任务；
						如果线程池中的线程数量大于 corePoolSize 时，如果某线程空闲时间超过keepAliveTime，线程将被终止，直至线程池中的线程数目不大于corePoolSize；
						如果允许为核心池中的线程设置存活时间，那么核心池中的线程空闲时间超过 keepAliveTime，线程也会被终止。

饱和策略：

Abort策略：默认策略，新任务提交时直接抛出未检查的异常RejectedExecutionException，该异常可由调用者捕获。
CallerRuns策略：为调节机制，既不抛弃任务也不抛出异常，而是将某些任务回退到调用者。不会在线程池的线程中执行新的任务，而是在调用exector的线程中运行新的任务。
Discard策略：新提交的任务被抛弃。