线程池

最新推荐文章于 2024-07-19 16:55:35 发布

fengzhuzhigu

最新推荐文章于 2024-07-19 16:55:35 发布

阅读量133

点赞数

分类专栏：并发

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

版权

并发专栏收录该内容

10 篇文章 0 订阅

订阅专栏

一. 线程池简介

线程池的概念：

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

线程池的工作机制

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

一个线程同时只能执行一个任务，但可以同时向一个线程池提交多个任务。

使用线程池的原因：

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

二. 五种常见的线程池详

线程池的返回值ExecutorService简介：
ExecutorService是Java提供的用于管理线程池的类。该类的两个作用：控制线程数量和重用线程
具体的5种常用的线程池实现如下：（返回值都是ExecutorService
2.1 Executors.newCacheThreadPool()：可缓存线程池，先查看池中有没有以前建立的线程，如果有，就直接使用。如果没有，就建一个新的线程加入池中，一般可以新建上万个线程，缓存型池子通常用于执行一些生存期很短的异步型任务，其中scheduleAtFixedRate(Runnable command, long initialDelay,
long period, TimeUnit unit)。initialDelay代表初始延期多少，period持续时间,unit代表时间单位（时分秒）。
示例代码：

1 
public class newScheduledThreadPool {
public static void main(String[] args) {
	ScheduledExecutorService service=Executors.newScheduledThreadPool(4);
	service.scheduleAtFixedRate
(()->{
		
		try {
			TimeUnit.MILLISECONDS.sleep(500);
			
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread().getName());
	},0,500,TimeUnit.MILLISECONDS);
}
}

输出结果：

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

线程池为无限大，当执行当前任务时上一个任务已经完成，会复用执行上一个任务的线程，而不用每次新建线程
2.2 Executors.newFixedThreadPool(int n)：创建一个可重用固定个数的线程池，以共享的无界队列方式来运行这些线程。
示例代码：

package com.study.test;
 2 
 3 import java.util.concurrent.ExecutorService;
 4 import java.util.concurrent.Executors;
 5 
 6 public class ThreadPoolExecutorTest {
 7     public static void main(String[] args) {
 8         //创建一个可重用固定个数的线程池
 9         ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
10         for (int i = 0; i < 10; i++) {
11             fixedThreadPool.execute(new Runnable() {
12                 public void run() {
13                     try {
14                         //打印正在执行的缓存线程信息
15                         System.out.println(Thread.currentThread().getName()+"正在被执行");
16                         Thread.sleep(2000);
17                     } catch (InterruptedException e) {
18                         e.printStackTrace();
19                     }
20                 }
21             });
22         }
23     }
24 }

输出结果：

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()

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

延迟执行示例代码：

 1 package com.study.test;
 2 
 3 import java.util.concurrent.Executors;
 4 import java.util.concurrent.ScheduledExecutorService;
 5 import java.util.concurrent.TimeUnit;
 6 
 7 public class ThreadPoolExecutorTest {
 8     public static void main(String[] args) {
 9         //创建一个定长线程池，支持定时及周期性任务执行——延迟执行
10         ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
11         //延迟1秒执行
12         scheduledThreadPool.schedule(new Runnable() {
13             public void run() {
14                 System.out.println("延迟1秒执行");
15             }
16         }, 1, TimeUnit.SECONDS);
17     }
18 }

输出结果：延迟1秒执行
定期执行示例代码：

package concurrent;


import java.util.concurrent.*;

public class ThreadPoolExecutorTest {

	public static void main(String[] args) {
		 //创建一个定长线程池，支持定时及周期性任务执行——延迟执行
		         ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
		        //延迟1秒后，每三秒执行一次
		        scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
		            public void run() {
		                System.out.println("延迟1秒后每3秒执行一次");
		            }
		        }, 1,3, TimeUnit.SECONDS);
		    }

	}

输出结果：

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

2.4 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

2.5 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类对象会负责子任务的执行。
在这里插入图片描述