多线程并发时，poolSize对执行时间的影响

最新推荐文章于 2021-06-18 15:27:39 发布
最新推荐文章于 2021-06-18 15:27:39 发布
阅读量396 收藏
点赞数
分类专栏： 多线程 文章标签： 多线程并发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013091257/article/details/85600071
版权

这两天在学习多线程并发，写了一个例子

import java.util.concurrent.Callable;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;

public class CountDownLatchTest {
	private static int poolSize = 2;
	private static CountDownLatch countDown = new CountDownLatch(poolSize);
	
	public static void main(String [] args) {

		long startTime = System.currentTimeMillis();
		System.out.println("主线程start use:" + startTime);
		Callable<String> call1 = new Callable<String>() {
		    @Override  
		    public String call() throws Exception {  
		        Thread.sleep(1000);  
		        countDown.countDown();
				System.out.println(Thread.currentThread().getName()+" user time "+(System.currentTimeMillis()-startTime));
		        //return the thread name executing this callable task  
		        return Thread.currentThread().getName();  
		    } 
			
		};
		Callable<String> call2 = new Callable<String>() {
		    @Override  
		    public String call() throws Exception {  
		        Thread.sleep(1000); 
		        countDown.countDown();  
		        System.out.println(Thread.currentThread().getName()+" user time "+(System.currentTimeMillis()-startTime));
		        //return the thread name executing this callable task  
		        return Thread.currentThread().getName();  
		    } 
			
		};
		
		FutureTask<String> ft1 = new FutureTask<String>(call1);
		FutureTask<String> ft2 = new FutureTask<String>(call2);
		
		ExecutorService executor = Executors.newFixedThreadPool(poolSize);
		
		executor.execute(ft1);
		executor.execute(ft2);

		try {
			countDown.await();
	        System.out.println(poolSize+"个子线程已经执行完毕");
	        System.out.println("主线程end use:" + (System.currentTimeMillis()-startTime));
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

执行结果：

主线程start use:1546396254696
pool-1-thread-2 user time 1011
2个子线程已经执行完毕
pool-1-thread-1 user time 1011
主线程end use:1011

 

恩，完美，执行效率挺高的

--------------------------------------------------------------------------------------

然后突然想到，如果poolSize设置成1呢，

import java.util.concurrent.Callable;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;

public class CountDownLatchTest {
	private static int poolSize = 1;
	private static CountDownLatch countDown = new CountDownLatch(poolSize);
	
	public static void main(String [] args) {

		long startTime = System.currentTimeMillis();
		System.out.println("主线程start use:" + startTime);
		Callable<String> call1 = new Callable<String>() {
		    @Override  
		    public String call() throws Exception {  
		        Thread.sleep(1000);  
		        countDown.countDown();
				System.out.println(Thread.currentThread().getName()+" user time "+(System.currentTimeMillis()-startTime));
		        //return the thread name executing this callable task  
		        return Thread.currentThread().getName();  
		    } 
			
		};
		Callable<String> call2 = new Callable<String>() {
		    @Override  
		    public String call() throws Exception {  
		        Thread.sleep(1000); 
		        countDown.countDown();  
		        System.out.println(Thread.currentThread().getName()+" user time "+(System.currentTimeMillis()-startTime));
		        //return the thread name executing this callable task  
		        return Thread.currentThread().getName();  
		    } 
			
		};
		
		FutureTask<String> ft1 = new FutureTask<String>(call1);
		FutureTask<String> ft2 = new FutureTask<String>(call2);
		
		ExecutorService executor = Executors.newFixedThreadPool(poolSize);
		
		executor.execute(ft1);
		executor.execute(ft2);

		try {
			countDown.await();
	        System.out.println(poolSize+"个子线程已经执行完毕");
	        System.out.println("主线程end use:" + (System.currentTimeMillis()-startTime));
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

执行结果：

主线程start use:1546396057514
pool-1-thread-1 user time 1011
1个子线程已经执行完毕
主线程end use:1011
pool-1-thread-1 user time 2011

 

这，执行时间翻倍了啊，

----------------------------------------------------------------------------------

然后我又给加了个Callable,代码就不上了，直接放结果

执行结果：

主线程start use:1546396574511
pool-1-thread-1 user time 1028
1个子线程已经执行完毕
主线程end use:1028
pool-1-thread-1 user time 2029
pool-1-thread-1 user time 3039

 

执行时间再次增加。。。。而且都是thread-1

 

结论：多线程情况下，如果有m个线程，线程池大小为n,poolSize = m<n?m:n,会先创建poolSize个线程,然后创建剩余线程，并且线程编号重新开始排序

 

是不是真的是这样呢，所有我又写了一个，1000个线程，但是每次会重新创建一次线程池，且size为1

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;

public class HighConcurrenceTest {
	private static int poolSize = 1000;
	private static CountDownLatch countDown = new CountDownLatch(poolSize);
	public static void main(String [] args) {
		List<FutureTask<String>> list = new ArrayList<FutureTask<String>>();
		long startTime = System.currentTimeMillis();
		System.out.println("主线程start use:" + startTime);
		for(int i = 0;i<poolSize;i++) {
			Callable<String> call = new Callable<String>() {
			    @Override  
			    public String call() throws Exception {  
			        Thread.sleep(1000);  
			        countDown.countDown();
					System.out.println(Thread.currentThread().getName()+" user time "+(System.currentTimeMillis()-startTime));
			        //return the thread name executing this callable task  
			        return Thread.currentThread().getName();  
			    } 
				
			};
			FutureTask<String> future = new FutureTask<String>(call);
			
			ExecutorService executor = Executors.newFixedThreadPool(1);
			executor.execute(future);
			
		}
		
		try {
			countDown.await();
			System.out.println("end use:" + (System.currentTimeMillis()-startTime));
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}
}

执行结果：

主线程start use:1546398444063
pool-84-thread-1 user time 1002
pool-82-thread-1 user time 1002
pool-86-thread-1 user time 1002

...

...
pool-832-thread-1 user time 1050
end use:1066
pool-834-thread-1 user time 1050

...

pool-823-thread-1 user time 1050
pool-826-thread-1 user time 1050
pool-827-thread-1 user time 1050

上边的程序，虽然有1000个线程，由于每次往线程池放一个线程，所以执行时间并没有受影响

--------------------------------------------------------------------------------------------------------------------------------

当然，实验不能就这样得结论，再测试一个

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;

public class HighConcurrenceTest {
	private static int poolSize = 1000;
	private static CountDownLatch countDown = new CountDownLatch(poolSize);
	public static void main(String [] args) {
		List<FutureTask<String>> list = new ArrayList<FutureTask<String>>();
		long startTime = System.currentTimeMillis();
		System.out.println("主线程start use:" + startTime);
		for(int i = 0;i<poolSize;i++) {
			Callable<String> call1 = new Callable<String>() {
			    @Override  
			    public String call() throws Exception {  
			        Thread.sleep(1000);  
			        countDown.countDown();
					System.out.println(Thread.currentThread().getName()+" user time "+(System.currentTimeMillis()-startTime));
			        //return the thread name executing this callable task  
			        return Thread.currentThread().getName();  
			    } 
				
			};
			Callable<String> call2 = new Callable<String>() {
			    @Override  
			    public String call() throws Exception {  
			        Thread.sleep(1000);  
			        countDown.countDown();
					System.out.println(Thread.currentThread().getName()+" user time "+(System.currentTimeMillis()-startTime));
			        //return the thread name executing this callable task  
			        return Thread.currentThread().getName();  
			    } 
				
			};
			FutureTask<String> future1 = new FutureTask<String>(call1);
			FutureTask<String> future2 = new FutureTask<String>(call2);
			
			ExecutorService executor = Executors.newFixedThreadPool(1);
			executor.execute(future1);
			executor.execute(future2);
			
		}
		
		try {
			countDown.await();
			System.out.println("end use:" + (System.currentTimeMillis()-startTime));
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}
}

执行结果：

主线程start use:1546398807709
pool-3-thread-1 user time 1013
pool-1-thread-1 user time 1013

...

...

pool-729-thread-1 user time 1080
end use:1080
pool-731-thread-1 user time 1080

...

pool-569-thread-1 user time 2112
pool-570-thread-1 user time 2112
pool-574-thread-1 user time 2112

-----------------------------------------------------------------------------------------------------------------------------

ok,这些可以得结论啦，撒花撒花。。。。

结论1：多线程情况下，如果有m个线程，线程池大小为n,poolSize = m<n?m:n,会先创建poolSize个线程,然后创建剩余线程，并且线程编号重新开始排序

结论2：多线程情况下，如果有m个线程，线程池大小为n,poolSize = m<n?m:n,会先创建poolSize个线程,然后创建剩余线程，并且线程编号重新开始排序，线程执行时间也会相应增加

如有理解错误，欢迎讨论

 

 

低头飞歌
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springmvc配置线程池Executor做多线程并发操作的代码实例
08-26
SpringMVC配置线程池Executor做多线程并发操作的代码实例 在本文中，我们将探讨如何使用SpringMVC框架来配置线程池Executor，以实现多线程并发操作。线程池Executor是Spring框架提供的一种线程池实现，它允许我们在...
关于多线程对程序执行时间的影响
ChenYitian
03-10 6553
多线程真的能加速程序的执行吗？ 假设有以下一个任务：读取一个文件，从文件中搜索指定的单词，统计个数。用以下两种方式完成： 1.开两个线程，一个线程负责读取文件，读取一个单词后扔给另一个线程，另一个线程负责检查这个单词是否匹配指定的单词。 2.只用一个线程，边读文件，读完一个单词以后，匹配这个单词，匹配出结果以后再读下一个单词。 两段程序的代码如下： 多线程程序：（文本文件用的是我在申请的
平均每个线程cpu运行时间_为什么说线程太多，cpu切换线程会浪费很多时间？
weixin_39722965的博客
12-03 696
问题1：假如有一个计算任务，计算1-100的和，每10个数相加，需要占用一个cpu时间片(1s)。如果起一个线程(模拟没有线程切换)，完成任务需要多长时间？如果起5个线程，完成任务需要消耗多久时间？如果起20个线程，完成任务需要多长时间？如果起20个线程呢？20个线程呢？50个线程呢？假设1：cpu是单核cpu假设2：每个线程的优先级一样。假设3：cpu在两个线程之间切换的时间消耗是0.1s。答：...
写给大忙人看的如何优雅设置线程池的大小
万猫学社
10-29 1万+
假如线程池的大小设置过大，线程上线文切换过于频繁，造成大量资源开销，反而会使性能降低；假如设置的太小，存在很多可用的处理器资源却未在工作，会造成资源的浪费和对吞吐量造成损失。如何优雅的设置线程池的大小呢？
java面试题总结-详细分类
Axin的博客
10-08 7300
技术点概念 1、Spring、SpringMvc、mybatis Spring是什么？干什么的？怎么用？ Spring是一个轻量级控制反转(IoC)和面向切面(AOP)的容器框架。 spring是一个万能的框架，方便解耦，开发，配置事务等等 Spring使用的是基本的JavaBean来完成以前只可能由EJB完成的事情。 Spring的核心机制是管理Bean SpringMVC是什么？干什么的？怎么用？ SpringMVC是Spring框架的一个模块，使用Spring进行WEB开发时，可以使用Spring M
程序什么时候应该使用线程，什么时候单线程效率高
ShiYi's blog
04-03 2485
对于处理时间短的服务或者启动频率高的要用单线程，相反用多线程！ 不论什么时候只要能用单线程就不用多线程，只有在需要响应时间要求比较高的情况下用多线程 某此操作允许并发而且该操作有可能阻塞时, 用多线程. 例如SOCKET, 磁盘操作. 使用多线程编程可以给程序员带来很大的灵活性，同时也使原来需要复杂技巧才能解决 的问题变得容易起来。但是，不应该人为地将编写的程序分成一些碎片，让这些碎片按 各自...
Java多线程执行处理业务时间太久解决方法代码示例
08-28
Java多线程执行处理业务时间太久解决方法代码示例 Java多线程执行处理业务时间太久解决方法代码示例主要介绍了Java多线程执行处理业务时间太久解决方法代码示例的相关资料，具有一定借鉴价值，需要的朋友可以参考下...
详解Springboot对多线程的支持
08-27
多线程和异步任务的使用有助于提高系统的并发能力，减少响应时间，但同时也需要注意线程安全问题，避免数据竞争和死锁等情况发生。 总的来说，Spring Boot通过TaskExecutor和ThreadPoolTaskExecutor为我们提供了一...
C++多线程封装成类使用示例
最新发布
12-19
在C++编程中，多线程是实现并发执行任务的关键技术。C++11标准引入了内置的`<thread>`库，使得多线程编程变得更加简单。本示例将详细介绍如何将C++的多线程功能封装成一个类，以便在实际项目中更加灵活地使用。 ...
多线程（二）
12-22
在Java编程中，多线程是并发处理任务的关键机制，特别是在高性能、高并发的应用场景下。然而，直接创建和管理大量的线程会带来资源浪费和性能瓶颈，这就是线程池的作用所在。线程池通过预先配置好的一组线程来处理...
JAVA获取所有线程的CPU执行时间，等待时间，阻塞时间
wenjiqiangke的专栏
06-18 5541
最近有个功能要查看所有线程的运行时间，走了一些弯路，在此总结一下。 1.获取所有线程的CPU执行时间 这里需要用到 java.lang.management.ThreadMXBean;
Java 进程中哪些线程占用了大量 CPU 处理时间
jie1521836的博客
07-20 473
1. 首先确定进程的 ID ，可以使用 jps -v 或者 top 命令直接查看 2. 查看该进程中哪个线程占用大量 CPU，执行 top -H -p [PID] 结果如下： 可以发现编号为 350xx 的共有 9 个线程占用了 100% 的 CPU，好，接下来咱们随便取一个线程 ID ，假设我们想看编号为 35053 这个线程。 首先将 35053 转成 16 进制是 88ED （可以...
java中四种线程池及poolSize、corePoolSize、maximumPoolSize
公众号：BennuCTech
01-04 4万+
Executors提供四种线程池： newCachedThreadPool ：缓存线程池，如果线程池长度超过处理需要，可回收空闲线程，若无可回收，则新建线程。newFixedThreadPool ： 定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。newScheduledThreadPool ： 计划线程池，支持定时及周期性任务执行。newSingleThreadExecutor...
线程池的corePoolSize、maximumPoolSize和poolSize
az44yao的专栏
04-01 1万+
什么是线程池： 为了避免系统频繁的创建和销毁线程，我们可以将创建的线程进行复用。在线程池中总有那么几个活跃的线程，也有一定的最大值限制，一个业务使用完线程之后，不是立即销毁而是将其放入到线程池中，从而实现线程的复用。简而言之：创建线程变成了从线程池获取空闲的线程，关闭线程变成了向池子中归还线程。 使用线程池的好处 Java中的线程池是运用场景最多的并发框架，几乎所有需要异步或并发执行任务的程...
线程池中 corePoolSize, maximumPoolSize, poolSize理解
weixin_33738982的博客
07-17 1364
2019独角兽企业重金招聘Python工程师标准>>> ...
ThreadPoolTaskScheduler注意事项之线程池大小poolSize以及通过JMX修改
天天向上
04-24 9043
在 Spring 中动态管理定时任务，通过简单的一句自动注入 ThreadPoolTaskScheduler 对象的代码，即可轻松实现，参见 Spring动态管理定时任务——ThreadPoolTaskScheduler 。 一、问题抛出 但如果没有查看 ThreadPoolTaskScheduler 的源码，则要特别注意 ThreadPoolTaskScheduler 中，初始化 poolS...
ThreadPoolExecutor线程池核心参数详解
大隐隐于野
06-26 3万+
理解ThreadPoolExecutor线程池的corePoolSize、maximumPoolSize和poolSize 我们知道，受限于硬件、内存和性能，我们不可能无限制的创建任意数量的线程，因为每一台机器允许的最大线程是一个有界值。也就是说ThreadPoolExecutor管理的线程数量是有界的。线程池就是用这些有限个数的线程，去执行提交的任务。然而对于多用户、高并发的应用来说，提交的任...
超时时间已到.错误及Max Pool Size设置
zgl8309的专栏
10-10 1825
<br />遇到这个错误：<br />超时时间已到。超时时间已到，但是尚未从池中获取连接。出现这种情况可能是因为所有池连接均在使用，并且达到了最大池大小。 <br />问题描述：我们获取连接超过连接池最大值时产生如上异常。通常连接池最大值为100。当我们获取连接超过最大值时，ADO.NET等待连接池返回连接而超时，这样将抛出如上异常<br />解决办法：首先要做的是在我们使用连接后立即关闭连接。如果没有关闭连接那么连接将保存到连接池中知道GC来销毁。这种情况下你以为连接池没有到达最大值但实际上连接池已经到达
理解ThreadPoolExecutor源码(一)线程池的corePoolSize、maximumPoolSize和poolSize
热门推荐
aty
09-13 5万+
我们知道，受限于硬件、内存和性能，我们不可能无限制的创建任意数量的线程，因为每一台机器允许的最大线程是一个有界值。也就是说ThreadPoolExecutor管理的线程数量是有界的。线程池就是用这些有限个数的线程，去执行提交的任务。然而对于多用户、高并发的应用来说，提交的任务数量非常巨大，一定会比允许的最大线程数多很多。为了解决这个问题，必须要引入排队机制，或者是在内存中，或者是在硬盘等容量很大的
使用JDK线程池实现高效多线程处理
在面临大量并发任务时，通过多线程并行处理，可以显著减少整体的执行时间。文中给出了具体的模块结构和源码解析，包括线程池配置、任务接口及其实现，以及服务接口的使用方法。" 在Java开发中，多线程技术是优化...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值