高并发编程和线程池----线程池ThreadPool&Executor

最新推荐文章于 2022-06-03 14:48:14 发布
最新推荐文章于 2022-06-03 14:48:14 发布
阅读量181 收藏
点赞数
分类专栏： 高并发编程和线程池
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Miracle_Gaaral/article/details/101234817
版权

一.Executor - 线程池底层处理机制。

/**
 * 线程池
 * 	Executor - 线程池底层处理机制。
 * 在使用线程池的时候，底层如何调用线程中的逻辑。
 */
package concurrent.t08;

import java.util.concurrent.Executor;

public class Test_01_MyExecutor implements Executor {
	public static void main(String[] args) {
		new Test_01_MyExecutor().execute(new Runnable() {
			@Override
			public void run() {
				System.out.println(Thread.currentThread().getName() + " - test executor");
			}
		});
	}

	@Override
	public void execute(Runnable command) {
		new Thread(command).start();
	}
}

----Future

/**
 * 线程池
 * 固定容量线程池
 */
package concurrent.t08;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;
import java.util.concurrent.TimeUnit;

public class Test_03_Future {
	
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		/*FutureTask<String> task = new FutureTask<>(new Callable<String>() {
			@Override
			public String call() throws Exception {
				return "first future task";
			}
		});
		
		new Thread(task).start();
		
		System.out.println(task.get());*/
		
		ExecutorService service = Executors.newFixedThreadPool(1);
		
		Future<String> future = service.submit(new Callable<String>() {
			@Override
			public String call() {
				try {
					TimeUnit.MILLISECONDS.sleep(500);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println("aaa");
				return Thread.currentThread().getName() + " - test executor";
			}
		});
		
		
		System.out.println(future);
		System.out.println(future.isDone()); // 查看线程是否结束， 任务是否完成。 call方法是否执行结束
		
		System.out.println(future.get()); // 获取call方法的返回值。
		System.out.println(future.isDone());
	}

}

二.线程池ThreadPool

----FixedThreadPool

/**
 * 线程池
 * 固定容量线程池
 * FixedThreadPool - 固定容量线程池。创建线程池的时候，容量固定。
 *  构造的时候，提供线程池最大容量
 * new xxxxx -> 
 * ExecutorService - 线程池服务类型。所有的线程池类型都实现这个接口。
 *  实现这个接口，代表可以提供线程池能力。
 *  shutdown - 优雅关闭。 不是强行关闭线程池，回收线程池中的资源。而是不再处理新的任务，将已接收的任务处理完毕后
 *      再关闭。
 * Executors - Executor的工具类。类似Collection和Collections的关系。
 *  可以更简单的创建若干种线程池。
 */
package concurrent.t08;

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

public class Test_02_FixedThreadPool {
	
	public static void main(String[] args) {
		ExecutorService service = 
				Executors.newFixedThreadPool(5);
		for(int i = 0; i < 6; i++){
			service.execute(new Runnable() {
				@Override
				public void run() {
					try {
						TimeUnit.MILLISECONDS.sleep(500);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName() + " - test executor");
				}
			});
		}
		
		System.out.println(service);
		
		service.shutdown();
		// 是否已经结束， 相当于回收了资源。
		System.out.println(service.isTerminated());
		// 是否已经关闭， 是否调用过shutdown方法
		System.out.println(service.isShutdown());
		System.out.println(service);
		
		try {
			TimeUnit.SECONDS.sleep(2);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		// service.shutdown();
		System.out.println(service.isTerminated());
		System.out.println(service.isShutdown());
		System.out.println(service);
	}

}

----Executors.newCachedThreadPool()

/**
 * 线程池
 * 无容量限制的线程池（最大容量默认为Integer.MAX_VALUE）
 */
package concurrent.t08;

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

public class Test_05_CachedThreadPool {
	
	public static void main(String[] args) {
		ExecutorService service = Executors.newCachedThreadPool();
		System.out.println(service);
		
		for(int i = 0; i < 5; i++){
			service.execute(new Runnable() {
				@Override
				public void run() {
					try {
						TimeUnit.MILLISECONDS.sleep(500);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName() + " - test executor");
				}
			});
		}
		
		System.out.println(service);
		
		try {
			TimeUnit.SECONDS.sleep(65);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		System.out.println(service);
	}

}

----Executors.newScheduledThreadPool(3)

/**
 * 线程池
 * 计划任务线程池。
 */
package concurrent.t08;

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

public class Test_07_ScheduledThreadPool {
	
	public static void main(String[] args) {
		ScheduledExecutorService service = Executors.newScheduledThreadPool(3);
		System.out.println(service);
		
		// 定时完成任务。 scheduleAtFixedRate(Runnable, start_limit, limit, timeunit)
		// runnable - 要执行的任务。
		service.scheduleAtFixedRate(new Runnable() {
			@Override
			public void run() {
				try {
					TimeUnit.MILLISECONDS.sleep(500);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName());
			}
		}, 5000, 300, TimeUnit.MILLISECONDS);
		
	}

}

----Executors.newSingleThreadExecutor()

/**
 * 线程池
 * 容量为1的线程池。 顺序执行。
 */
package concurrent.t08;

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

public class Test_06_SingleThreadExecutor {
	
	public static void main(String[] args) {
		ExecutorService service = Executors.newSingleThreadExecutor();
		System.out.println(service);
		
		for(int i = 0; i < 5; i++){
			service.execute(new Runnable() {
				@Override
				public void run() {
					try {
						TimeUnit.MILLISECONDS.sleep(500);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName() + " - test executor");
				}
			});
		}
		
	}

}

----ForkJoinPool()

/**
 * 线程池
 * 分支合并线程池。
 */
package concurrent.t08;

import java.io.IOException;
import java.util.Random;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.Future;
import java.util.concurrent.RecursiveTask;

public class Test_08_ForkJoinPool {
	
	final static int[] numbers = new int[1000000];
	final static int MAX_SIZE = 50000;
	final static Random r = new Random();
	
	
	static{
		for(int i = 0; i < numbers.length; i++){
			numbers[i] = r.nextInt(1000);
		}
	}
	
	static class AddTask extends RecursiveTask<Long>{ // RecursiveAction
		int begin, end;
		public AddTask(int begin, int end){
			this.begin = begin;
			this.end = end;
		}
		
		// 
		protected Long compute(){
			if((end - begin) < MAX_SIZE){
				long sum = 0L;
				for(int i = begin; i < end; i++){
					sum += numbers[i];
				}
				// System.out.println("form " + begin + " to " + end + " sum is : " + sum);
				return sum;
			}else{
				int middle = begin + (end - begin)/2;
				AddTask task1 = new AddTask(begin, middle);
				AddTask task2 = new AddTask(middle, end);
				task1.fork();// 就是用于开启新的任务的。 就是分支工作的。 就是开启一个新的线程任务。
				task2.fork();
				// join - 合并。将任务的结果获取。 这是一个阻塞方法。一定会得到结果数据。
				return task1.join() + task2.join();
			}
		}
	}
	
	public static void main(String[] args) throws InterruptedException, ExecutionException, IOException {
		long result = 0L;
		for(int i = 0; i < numbers.length; i++){
			result += numbers[i];
		}
		System.out.println(result);
		
		ForkJoinPool pool = new ForkJoinPool();
		AddTask task = new AddTask(0, numbers.length);
		
		Future<Long> future = pool.submit(task);
		System.out.println(future.get());
		
	}

}

----ThreadPoolExecutor

/**
 * 线程池
 * 固定容量线程池
 */
package concurrent.t08;

import java.util.ArrayList;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Test_09_ThreadPoolExecutor {
	
	public static void main(String[] args) {
		// 模拟fixedThreadPool， 核心线程5个，最大容量5个，线程的生命周期无限。
		ExecutorService service = 
				new ThreadPoolExecutor(5, 5, 0L, TimeUnit.MILLISECONDS, 
						new LinkedBlockingQueue<Runnable>());
		
		for(int i = 0; i < 6; i++){
			service.execute(new Runnable() {
				@Override
				public void run() {
					try {
						TimeUnit.MILLISECONDS.sleep(500);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName() + " - test executor");
				}
			});
		}
		
		System.out.println(service);
		
		service.shutdown();
		System.out.println(service.isTerminated());
		System.out.println(service.isShutdown());
		System.out.println(service);
		
		try {
			TimeUnit.SECONDS.sleep(2);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		service.shutdown();
		System.out.println(service.isTerminated());
		System.out.println(service.isShutdown());
		System.out.println(service);
		
	}

}

 

Miracle_Gaaral
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
面试必问并发编程高级面试专题-09.rar
03-02
并发编程是计算机科学中的一个重要领域，特别是在高并发系统设计中，它是优化性能、提升系统效率的关键。本专题针对的是高级面试中的...深入理解和熟练掌握这些内容，将有助于在面试中表现出对高并发编程的深厚功底。
线程池
qq_38019655的博客
11-03 328
线程池 一、ExecutorService接口 　　常用的实现类：ThreadPoolExecutor，参数： 　　corePoolSize - 核心线程数，池中所保存的线程数，包括空闲线程。 　　maximumPoolSize - 池中允许的最大线程数=核心线程数+临时线程数。 　　keepAliveTime - 临时线程等待新任务的最长时间。 　　unit - keepAliveTime 参数...
ThreadPoolExecutor线程方法
Edyx的博客
05-03 814
public class MyThreadPoolDemo { public static void main(String[] args){ Lock lock = new ReentrantLock(true); ExecutorService threadPool = new ThreadPoolExecutor(2, 5, 2L, TimeUnit.SECOND
白盒测试中如何实现真正意义上并发测试（Java）
热门推荐
08-04 41万+
在这个话题开始之前，首先我们来弄清楚为什么要做并发测试？一般并发测试，是指模拟并发访问，测试多用户并发访问同一个应用、模块、数据时是否产生隐藏的并发问题，如内存泄漏、线程锁、资源争用问题。站在性能测试的角度，并发测试不是为了获得性能指标，而是为了发现并发引起的问题。那么并发对应的技术实现到底是怎样的呢？简单地说，并发是指多个进程或线程在某一时刻同时处理指定的操作，有点类似于性能测试中集合点的概念，讲
LinkedBlockingQueue源码分析
09的专栏
08-18 441
前言 在前面的文章ArrayBlockingQueue源码分析中，已经对JDK中的BlockingQueue中的做了一个回顾，同时对ArrayBlockingQueue中的核心方法作了说明，而LinkedBlockingQueue作为JDK中BlockingQueue家族系列中一员，由于其作为固定大小线程池(Executors.newFixedThreadPool())底层所使用的阻塞队列，分析
@阻塞队列和线程池
weixin_49329785的博客
06-03 1432
阻塞队列 当队列是空的，从队列中获取元素的操作将会被阻塞 当队列是满的，从队列中添加元素的操作将会被阻塞 试图从空的队列中获取元素的线程将会被阻塞，直到其他线程往空的队列插入新的元素 试图向已满的队列中添加新元素的线程将会被阻塞，直到其他线程从队列中移除一个或多个元素或者完全清空，使队列变得空闲起来并后续新增 常见的BlockingQueue 1.ArrayBlockingQueue(常用) 2.LinkedBlockingQueue(常用) 3.DelayQueue 4...
浅谈java.util.concurrent包中的线程池和消息队列
08-25
java.util.concurrent包中的线程池和消息队列是一种高效的多线程编程技术，主要用于解决处理器单元内多个线程执行的问题。线程池技术可以显著减少处理器单元的闲置时间，增加处理器单元的吞吐能力。 1. 并发包介绍 ...
实例代码讲解Python 线程池
12-17
`ThreadPoolExecutor`提供了一种更高级别的接口，可以方便地管理和控制线程池，包括异步执行、获取结果和异常处理等。 使用线程池的优点包括： - **资源管理**：线程池预先创建一定数量的线程，避免了频繁创建和...
ThreadPool:用C ++ 11和Folly实现的简单线程池（facebook C ++基础库）
04-28
然而，如果没有管理，这种线程的创建和销毁可能会导致资源的浪费，尤其是在高并发场景下。线程池通过维护一组工作线程，将任务放入队列，当有空闲线程时，就从队列中取出任务进行处理，从而提高了系统效率。 Folly...
使用IO完成端口机制实现的定制线程池的代码
03-23
在Java等编程语言中，线程池是通过执行器（Executor）框架实现的，尤其是`java.util.concurrent`包中的`ThreadPoolExecutor`类。线程池通过减少创建和销毁线程的开销，优化系统资源的分配，可以显著提高系统的并发...
线程池ThreadPoolExecutor详解以及用法示例-详细的执行流程和内部解剖
mischen520的博客
03-20 1415
1.先看一个面试题 如果corepollSize=10,MaxPollSize=20,如果来了40个线程 怎么办？ 要想回答这一个问题，其实不难，只要了解了线程池内部的工作原理就知道怎么回答了。先来看看线程池的整个运行机制： 当一个任务通过execute(Runnable)方法欲添加到线程池时： 1、 如果此时线程池中的数量小于corePoolSize，即使线程池中的线程都处于空闲状态，也要创建新的线程来处理被添加的任务。 2、 如果此时线程池中的数量等于 corePoolSize，但是缓冲队列
LinkedBlockingQueue应用详解
wkend的博客
01-01 6085
一． 概述及应用场景 Jdk源码注释：（JDK1.9）/** 1. An optionally-bounded {@linkplain BlockingQueue blocking queue} based on 2. linked nodes. 3. This queue orders elements FIFO (first-in-first-out). 4. The <em>h
进阶篇:同步阻塞队列之LinkedBlockingQueue(十一)
打着吊瓶写代码的博客
04-12 1780
JDK为我们提供了多个阻塞队列的实现，什么是阻塞队列呢？ 我们都知道队列就是一组数据的集合，而阻塞队列的意思是，当你往队列中取数据时，如果没有数据，你将被阻塞，一直等到拿到数据为止； 今天我们就来看一下比较常用的遵循先进先出的阻塞队列LinkedBlockingQueue； //同步阻塞队列 //可以看到，当调用take()方法去拿数据时，如果里面没有数据，将造成阻塞 public sta
ThreadPoolExecutor使用LinkedBlockingQueue的坑
chouxibo9351的博客
08-24 981
坑的描述 ThreadPoolExecutor threadPool = new ThreadPoolExecutor( 4, // corePoolSize 64, // maximumPoolSize 60L, // keepAliveTime TimeUn...
Java线程池的核心线程数和最大线程数
心要是孤单了，到了那里都是流浪~~~
03-14 2万+
Java的线程池就像是一个花瓶容器。 而把任务提交给线程池就像是把小球塞进花瓶。 整个过程就像下面这个有趣的动画： 下面我们先来了解一下Java线程池的参数。 希望看完这篇文章后, 再提起线程池的时候, 你脑海首先出现的, 会是一个花瓶 : ) 1线程池的参数意义 Java线程池的构造函数如下： public ThreadPoolExecutor（ int corePoolSize, int maximumPoolSize, long keepAliveTime, Ti.
Java线程池ThreadPoolExecutor
JoesaCSDN的博客
04-01 2426
线程池ThreadPoolExecutor 1、类关系 Executor 是一个接口， 它是 Executor 框架的基础， 它将任务的提交与任务的执行分离开来。 ExecutorService 接口继承了 Executor【原来接口是可以继承接口的】， 在其上做了一些shutdown()、 submit()的扩展， 可以说是真正的线程池接口。 AbstractExecutorService 抽象类实现了 ExecutorService 接口中的大部分方法。 ThreadPoolExecutor 是线程
Java多线程学习笔记5——ThreadPoolExecutor
zhangkang65的专栏
05-06 225
阿里代码规范中规定，线程资源必须通过线程池提供，不允许在应用中自行显示的创建线程。这样做的好处是减少在创建和销毁所花的时间和系统开销。不使用线程池可能造成创建大量同类线程而导致消耗内存或则“过度切换”的问题。并且规定线程池不允许使用Executors创建。那么创建线程的方式基本就依赖于ThreadPoolExecutor此类了。 先了解下ThreadPoolExecutor的构造函数： //...
超市管理系统，基于javaweb.zip
最新发布
08-15
项目工程资源经过严格测试可直接运行成功且功能正常的情况才上传，可轻松copy复刻，拿到资料包后可轻松复现出一样的项目，本人系统开发经验充足（全栈开发），有任何使用问题欢迎随时与我联系，我会及时为您解惑，提供帮助 【资源内容】：项目具体内容可查看/点击本页面下方的*资源详情*，包含完整源码+工程文件+说明（若有）等。【若无积分，此资源可私信获取】 【本人专注IT领域】：有任何使用问题欢迎随时与我联系，我会及时解答，第一时间为您提供帮助 【附带帮助】：若还需要相关开发工具、学习资料等，我会提供帮助，提供资料，鼓励学习进步 【适合场景】：相关项目设计中，皆可应用在项目开发、毕业设计、课程设计、期末/期中/大作业、工程实训、大创等学科竞赛比赛、初期项目立项、学习/练手等方面中 可借鉴此优质项目实现复刻，也可基于此项目来扩展开发出更多功能 #注 1. 本资源仅用于开源学习和技术交流。不可商用等，一切后果由使用者承担 2. 部分字体及插图等来自网络，若是侵权请联系删除，本人不对所涉及的版权问题或内容负法律责任。收取的费用仅用于收集和整理资料耗费时间的酬劳
vue3面试题2023,84页，几十道vue面试题，准备vue的面试，这么一份文件就够了
08-15
vue3面试题2023： Vue 的优缺点  优点 1.创建单页面应用的轻量级Web应用框架 2.简单易用 3.双向数据绑定 4.组件化的思想 5.虚拟DOM 6.数据驱动视图 缺点 不支持IE8
Java并发编程实践基础-第一章详解
Java通过Thread类和Runnable接口提供线程创建的支持，另外，线程池（ThreadPool）是一种更高效管理线程的方式，可以避免频繁创建和销毁线程的开销。 1.2 创建多线程 - 继承Thread类创建线程：自定义类继承Thread，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值