多线程池newFixedThreadPool之动态多线程池做线程池隔离

最新推荐文章于 2024-05-26 15:37:03 发布
最新推荐文章于 2024-05-26 15:37:03 发布
阅读量1.7k 收藏 4
点赞数 3
分类专栏： java 并发 文章标签： 线程池 多线程 线程池隔离 高并发 动态线程池
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sijingqian/article/details/78332676
版权

背景

     本文不是讲述线程池的基本知识，而是在做爬虫项目实际情况，碰到技术解决方案，简单的线程隔离的实践，在做爬虫时，会碰到反应慢和反应快的各种网站，如何同时用一个线程池去做爬虫请求，慢的网站会堵塞快的网站请求，这是就考虑线程隔离。线程池基于newFixedThreadPool（）创建。

本文部分描述性内容来源于网络，其中示例性Java源代码经过本人亲自测试，如有不当、错误或侵权行为敬请指正。


   基于下图：


ps:这小伙只是提供具体实现方案，没看到具体代码，只能自己实现了！


实现功能：

 DynamicAsyncTaskService.java

/**
 * 动态线程池
 * @author wuche
 * @version 暂时固定写死的，后期可以改造成基于spring建实例模式，或者基于懒加载模式创建
 */
public class DynamicAsyncTaskService {

	private static DynamicAsyncTaskService service;
	//最大线程数(可以放使用多个)
	public static int executorPoolSize =10;
	//最大线程数（可以放少的）
	public static int executorPoolSize2 =5;
	//线程前缀名
	public static String poolName ="1";
	//线程前缀名
	public static String poolName2 ="2";
	private  ThreadPoolExecutor pool = (ThreadPoolExecutor) Executors.newFixedThreadPool(executorPoolSize, setThreadFactory(poolName));
	private  ThreadPoolExecutor pool2 = (ThreadPoolExecutor) Executors.newFixedThreadPool(executorPoolSize2, setThreadFactory(poolName2));
	public static DynamicAsyncTaskService getInstance() {
		if (service == null) {
			service = new DynamicAsyncTaskService();
		}
		return service;
	}
    private ThreadFactory setThreadFactory(String poolName){
    	return new DefaultThreadFactory(poolName);
    }
    
    private ThreadPoolExecutor getPool(int i){
    	ThreadPoolExecutor newPool=null;
    	if(i==1){
    		newPool=pool;
    	}else{
    		newPool=pool2;
    	}
    	return newPool;
    }
    
    private int getPoolSize(int i){
		int poolSize=executorPoolSize;
		if(i==1){
			poolSize=executorPoolSize;
		}else{
			poolSize=executorPoolSize2;
		}
		return poolSize;
	}
    /**
     * 获取可以使用线程数
     * @param i
     * @return
     */
	public int getAvailableNum(int i) {
		return getPoolSize(i)-getPool(i).getActiveCount();
	}
	
	/**
	 * 获取活动线程数
	 * @param i
	 * @return
	 */
	public int getActiveNum(int i) {
		return getPool(i).getPoolSize();
	}
	/**
	 * 正在排队的线程数
	 * @return
	 */
	public int getQueueNum(int i) {
		return getPool(i).getQueue().size();
	}
	
	public void execute(Runnable command,int i) {
		getPool(i).execute(command);
	}
	
	@SuppressWarnings({ "rawtypes", "unchecked" })
	public Future submit(Callable task,int i) {
		return getPool(i).submit(task);
	}

	@SuppressWarnings("rawtypes")
	public Future submit(Runnable task, Object result,int i) {
		return getPool(i).submit(task, result);
	}
	
	/**
	 * 自定义的ThreadFactory，便于日志打印
	 * @author wuche
	 *
	 */
	static class DefaultThreadFactory implements ThreadFactory {  
	    private static final AtomicInteger poolNumber = new AtomicInteger(1);  
	    private final ThreadGroup group;  
	    private final AtomicInteger threadNumber = new AtomicInteger(1);  
	    private String namePrefix;  
	  
	    DefaultThreadFactory(String poolName) {  
	        SecurityManager s = System.getSecurityManager();  
	        group = (s != null) ? s.getThreadGroup() :  Thread.currentThread().getThreadGroup();  
	        namePrefix = "pool"+poolName +"-"+  poolNumber.getAndIncrement() +  "-thread-";  
	    }  
	    // 为线程池创建新的任务执行线程  
	    public Thread newThread(Runnable r) { 
	        // 线程对应的任务是Runnable对象r  
	        Thread t = new Thread(group, r,namePrefix + threadNumber.getAndIncrement(), 0);  
	        // 设为非守护线程  
	        if (t.isDaemon())  
	            t.setDaemon(false);  
	        // 将优先级设为Thread.NORM_PRIORITY  
	        if (t.getPriority() != Thread.NORM_PRIORITY)  
	            t.setPriority(Thread.NORM_PRIORITY);  
	        return t;  
	    }
		public String getNamePrefix() {
			return namePrefix;
		}
		public void setNamePrefix(String namePrefix) {
			this.namePrefix = namePrefix;
		}  
	    
	} 
}
测试类：TestAsyncTask.java 

package com.haohan.thread;


public class TestAsyncTask {
	public static void main(String[] args){
        for (int i = 0; i < 35; i++) {
        	final long startTime=System.currentTimeMillis();
        	if(i%2==0){
        		System.out.println("线程一开始：：---");
        		DynamicAsyncTaskService.getInstance().execute(new Runnable() {
                    @Override
                    public void run() {
                        try {
                        	System.out.println("正在运行线程名字："+Thread.currentThread().getName());
                        	 System.out.println("线程池中现在的线程数目是："+DynamicAsyncTaskService.getInstance().getActiveNum(1)+",队列中正在等待执行的任务数量为："+ DynamicAsyncTaskService.getInstance().getQueueNum(1)
                                		+",可利用的线程数目："+DynamicAsyncTaskService.getInstance().getAvailableNum(1)
                                		);
                            Thread.currentThread().sleep(1000);
                            long endTime=System.currentTimeMillis();
                            System.out.println(Thread.currentThread().getName()+"结束时间"+(endTime-startTime));
                            System.out.println("线程池中现在的线程数目是："+DynamicAsyncTaskService.getInstance().getActiveNum(1)+",队列中正在等待执行的任务数量为："+ DynamicAsyncTaskService.getInstance().getQueueNum(1)
                             		+",可利用的线程数目："+DynamicAsyncTaskService.getInstance().getAvailableNum(1)
                             		);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                },1);
        	}else{
        		DynamicAsyncTaskService.getInstance().execute(new Runnable() {
                    @Override
                    public void run() {
                        try {
                        	System.out.println("正在运行线程名字："+Thread.currentThread().getName());
                        	 System.out.println("线程池中现在的线程数目2是："+DynamicAsyncTaskService.getInstance().getActiveNum(2)+",队列中正在等待执行的任务2数量为："+ DynamicAsyncTaskService.getInstance().getQueueNum(2)
                                		+",可利用的线程2数目："+DynamicAsyncTaskService.getInstance().getAvailableNum(2)
                                		);
                            Thread.currentThread().sleep(1000);
                            long endTime=System.currentTimeMillis();
                            System.out.println(Thread.currentThread().getName()+"结束时间"+(endTime-startTime));
                            System.out.println("线程池中现在的线程数目是："+DynamicAsyncTaskService.getInstance().getActiveNum(1)+",队列中正在等待执行的任务数量为："+ DynamicAsyncTaskService.getInstance().getQueueNum(1)
                             		+",可利用的线程数目："+DynamicAsyncTaskService.getInstance().getAvailableNum(1)
                             		);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                },2);
        		  
        	}
         
        }
		
		/*System.out.println(Runtime.getRuntime().availableProcessors());*/
    }
}

测试结果： 

线程一开始：：---
正在运行线程名字：pool1-1-thread-1
线程池中现在的线程数目是：1,队列中正在等待执行的任务数量为：0,可利用的线程数目：9
线程一开始：：---
正在运行线程名字：pool2-2-thread-1
线程池中现在的线程数目2是：1,队列中正在等待执行的任务2数量为：0,可利用的线程2数目：4
正在运行线程名字：pool1-1-thread-2
线程池中现在的线程数目是：2,队列中正在等待执行的任务数量为：0,可利用的线程数目：8
线程一开始：：---
正在运行线程名字：pool2-2-thread-2
线程池中现在的线程数目2是：2,队列中正在等待执行的任务2数量为：0,可利用的线程2数目：3
正在运行线程名字：pool1-1-thread-3
线程池中现在的线程数目是：3,队列中正在等待执行的任务数量为：0,可利用的线程数目：7
线程一开始：：---
正在运行线程名字：pool2-2-thread-3
线程池中现在的线程数目2是：3,队列中正在等待执行的任务2数量为：0,可利用的线程2数目：2
线程一开始：：---
正在运行线程名字：pool2-2-thread-4
线程池中现在的线程数目2是：4,队列中正在等待执行的任务2数量为：0,可利用的线程2数目：1
线程一开始：：---
正在运行线程名字：pool1-1-thread-5
线程池中现在的线程数目是：6,队列中正在等待执行的任务数量为：0,可利用的线程数目：4
正在运行线程名字：pool1-1-thread-4
线程池中现在的线程数目是：6,队列中正在等待执行的任务数量为：0,可利用的线程数目：4
正在运行线程名字：pool2-2-thread-5
线程池中现在的线程数目2是：5,队列中正在等待执行的任务2数量为：1,可利用的线程2数目：0
线程一开始：：---
正在运行线程名字：pool1-1-thread-6
线程池中现在的线程数目是：7,队列中正在等待执行的任务数量为：0,可利用的线程数目：3
线程一开始：：---
正在运行线程名字：pool1-1-thread-7
线程池中现在的线程数目是：8,队列中正在等待执行的任务数量为：0,可利用的线程数目：2
线程一开始：：---
线程一开始：：---
正在运行线程名字：pool1-1-thread-9
线程一开始：：---
正在运行线程名字：pool1-1-thread-8
线程一开始：：---
线程一开始：：---
线程一开始：：---
线程一开始：：---
线程一开始：：---
线程一开始：：---
线程一开始：：---
正在运行线程名字：pool1-1-thread-10
线程池中现在的线程数目是：10,队列中正在等待执行的任务数量为：8,可利用的线程数目：0
线程池中现在的线程数目是：10,队列中正在等待执行的任务数量为：0,可利用的线程数目：0
线程池中现在的线程数目是：10,队列中正在等待执行的任务数量为：1,可利用的线程数目：0
pool1-1-thread-1结束时间1008
线程池中现在的线程数目是：10,队列中正在等待执行的任务数量为：8,可利用的线程数目：0
正在运行线程名字：pool1-1-thread-1
线程池中现在的线程数目是：10,队列中正在等待执行的任务数量为：7,可利用的线程数目：0
pool1-1-thread-2结束时间1000
线程池中现在的线程数目是：10,队列中正在等待执行的任务数量为：7,可利用的线程数目：0
正在运行线程名字：pool1-1-thread-2
线程池中现在的线程数目是：10,队列中正在等待执行的任务数量为：6,可利用的线程数目：0
pool2-2-thread-1结束时间1010
线程池中现在的线程数目是：10,队列中正在等待执行的任务数量为：6,可利用的线程数目：0
正在运行线程名字：pool2-2-thread-1
线程池中现在的线程数目2是：5,队列中正在等待执行的任务2数量为：11,可利用的线程2数目：0
pool2-2-thread-3结束时间1000
线程池中现在的线程数目是：10,队列中正在等待执行的任务数量为：6,可利用的线程数目：0
正在运行线程名字：pool2-2-thread-3
线程池中现在的线程数目2是：5,队列中正在等待执行的任务2数量为：10,可利用的线程2数目：0
pool2-2-thread-2结束时间1001
线程池中现在的线程数目是：10,队列中正在等待执行的任务数量为：6,可利用的线程数目：0
正在运行线程名字：pool2-2-thread-2
线程池中现在的线程数目2是：5,队列中正在等待执行的任务2数量为：9,可利用的线程2数目：0
pool1-1-thread-3结束时间1002
线程池中现在的线程数目是：10,队列中正在等待执行的任务数量为：6,可利用的线程数目：0
正在运行线程名字：pool1-1-thread-3
线程池中现在的线程数目是：10,队列中正在等待执行的任务数量为：5,可利用的线程数目：0
pool2-2-thread-4结束时间1001
线程池中现在的线程数目是：10,队列中正在等待执行的任务数量为：5,可利用的线程数目：0
正在运行线程名字：pool2-2-thread-4
线程池中现在的线程数目2是：5,队列中正在等待执行的任务2数量为：8,可利用的线程2数目：0
pool2-2-thread-5结束时间1001
线程池中现在的线程数目是：10,队列中正在等待执行的任务数量为：5,可利用的线程数目：0
正在运行线程名字：pool2-2-thread-5
线程池中现在的线程数目2是：5,队列中正在等待执行的任务2数量为：7,可利用的线程2数目：0
pool1-1-thread-4结束时间1002
线程池中现在的线程数目是：10,队列中正在等待执行的任务数量为：5,可利用的线程数目：0
正在运行线程名字：pool1-1-thread-4
线程池中现在的线程数目是：10,队列中正在等待执行的任务数量为：4,可利用的线程数目：0
pool1-1-thread-6结束时间1002
线程池中现在的线程数目是：10,队列中正在等待执行的任务数量为：4,可利用的线程数目：0
正在运行线程名字：pool1-1-thread-6
线程池中现在的线程数目是：10,队列中正在等待执行的任务数量为：3,可利用的线程数目：0
pool1-1-thread-9结束时间1003
线程池中现在的线程数目是：10,队列中正在等待执行的任务数量为：3,可利用的线程数目：0
正在运行线程名字：pool1-1-thread-9
线程池中现在的线程数目是：10,队列中正在等待执行的任务数量为：2,可利用的线程数目：0
pool1-1-thread-10结束时间1003
线程池中现在的线程数目是：10,队列中正在等待执行的任务数量为：2,可利用的线程数目：0
正在运行线程名字：pool1-1-thread-10
线程池中现在的线程数目是：10,队列中正在等待执行的任务数量为：1,可利用的线程数目：0
pool1-1-thread-7结束时间1005
线程池中现在的线程数目是：10,队列中正在等待执行的任务数量为：1,可利用的线程数目：0
正在运行线程名字：pool1-1-thread-7
线程池中现在的线程数目是：10,队列中正在等待执行的任务数量为：0,可利用的线程数目：0
pool1-1-thread-8结束时间1005
线程池中现在的线程数目是：10,队列中正在等待执行的任务数量为：0,可利用的线程数目：0
pool1-1-thread-5结束时间1007
线程池中现在的线程数目是：10,队列中正在等待执行的任务数量为：0,可利用的线程数目：1
pool1-1-thread-1结束时间1987
线程池中现在的线程数目是：10,队列中正在等待执行的任务数量为：0,可利用的线程数目：2
pool2-2-thread-1结束时间1997
线程池中现在的线程数目是：10,队列中正在等待执行的任务数量为：0,可利用的线程数目：3
正在运行线程名字：pool2-2-thread-1
线程池中现在的线程数目2是：5,队列中正在等待执行的任务2数量为：6,可利用的线程2数目：0
pool1-1-thread-2结束时间1996
线程池中现在的线程数目是：10,队列中正在等待执行的任务数量为：0,可利用的线程数目：3
pool2-2-thread-3结束时间1997
线程池中现在的线程数目是：10,队列中正在等待执行的任务数量为：0,可利用的线程数目：4
正在运行线程名字：pool2-2-thread-3
线程池中现在的线程数目2是：5,队列中正在等待执行的任务2数量为：5,可利用的线程2数目：0
pool1-1-thread-4结束时间2001
线程池中现在的线程数目是：10,队列中正在等待执行的任务数量为：0,可利用的线程数目：4
pool2-2-thread-5结束时间2001
线程池中现在的线程数目是：10,队列中正在等待执行的任务数量为：0,可利用的线程数目：5
正在运行线程名字：pool2-2-thread-5
线程池中现在的线程数目2是：5,队列中正在等待执行的任务2数量为：4,可利用的线程2数目：0
pool2-2-thread-2结束时间2003
线程池中现在的线程数目是：10,队列中正在等待执行的任务数量为：0,可利用的线程数目：5
正在运行线程名字：pool2-2-thread-2
线程池中现在的线程数目2是：5,队列中正在等待执行的任务2数量为：3,可利用的线程2数目：0
pool1-1-thread-3结束时间2003
线程池中现在的线程数目是：10,队列中正在等待执行的任务数量为：0,可利用的线程数目：5
pool2-2-thread-4结束时间2003
线程池中现在的线程数目是：10,队列中正在等待执行的任务数量为：0,可利用的线程数目：6
正在运行线程名字：pool2-2-thread-4
线程池中现在的线程数目2是：5,队列中正在等待执行的任务2数量为：2,可利用的线程2数目：0
pool1-1-thread-6结束时间2003
线程池中现在的线程数目是：10,队列中正在等待执行的任务数量为：0,可利用的线程数目：6
pool1-1-thread-9结束时间2003
线程池中现在的线程数目是：10,队列中正在等待执行的任务数量为：0,可利用的线程数目：7
pool1-1-thread-10结束时间2004
线程池中现在的线程数目是：10,队列中正在等待执行的任务数量为：0,可利用的线程数目：8
pool1-1-thread-7结束时间2005
线程池中现在的线程数目是：10,队列中正在等待执行的任务数量为：0,可利用的线程数目：9
pool2-2-thread-1结束时间2996
线程池中现在的线程数目是：10,队列中正在等待执行的任务数量为：0,可利用的线程数目：10
正在运行线程名字：pool2-2-thread-1
线程池中现在的线程数目2是：5,队列中正在等待执行的任务2数量为：1,可利用的线程2数目：0
pool2-2-thread-3结束时间2997
线程池中现在的线程数目是：10,队列中正在等待执行的任务数量为：0,可利用的线程数目：10
正在运行线程名字：pool2-2-thread-3
线程池中现在的线程数目2是：5,队列中正在等待执行的任务2数量为：0,可利用的线程2数目：0
pool2-2-thread-5结束时间3001
线程池中现在的线程数目是：10,队列中正在等待执行的任务数量为：0,可利用的线程数目：10
pool2-2-thread-4结束时间3003
线程池中现在的线程数目是：10,队列中正在等待执行的任务数量为：0,可利用的线程数目：10
pool2-2-thread-2结束时间3003
线程池中现在的线程数目是：10,队列中正在等待执行的任务数量为：0,可利用的线程数目：10
pool2-2-thread-1结束时间3996
线程池中现在的线程数目是：10,队列中正在等待执行的任务数量为：0,可利用的线程数目：10
pool2-2-thread-3结束时间3997
线程池中现在的线程数目是：10,队列中正在等待执行的任务数量为：0,可利用的线程数目：10

从以上结果可以看出，newFixedThreadPool的参数指定了可以运行的线程的最大数目，超过这个数目的线程加进去以后，不会立即运行，而是被放入任务队列中等待执行。其次，加入线程池的线程属于托管状态，线程的运行不受加入顺序的影响。并且两个线程池是不会相互影响的！

该场景可以用到需要多线程业务当中是没问题的！！


sijingqian
关注
  • 3
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线程池管理多线程上传
01-15
线程池管理和多线程上传是并发编程中的一个重要实践，特别是在大数据传输和网络服务中。在Java等编程语言中，线程池通过有效地管理和复用线程资源，避免了频繁创建和销毁线程带来的开销，提升了系统性能。下面将详细...
java简单实现多线程及线程池实例详解
08-27
"java简单实现多线程及线程池实例详解" 在java中，多线程是指在一个程序中可以同时运行多个线程，以提高程序的执行效率和性能。java提供了两种方式来实现多线程，即继承Thread类和实现Runnable接口。 继承Thread类...
newFixedThreadPool
qq_25622107的博客
10-25 1051
在上一章中我们概述了一下线程池，这一章我们看一下创建newFixedThreadPool的源码。例子还是我们在上一章中写的那个例子。 创建newFixedThreadPool的方法： [java] view plain copy public static ExecutorService newFixedThreadPool(int nTh
ExecutorService常用方法和newFixedThreadPool创建固定大小的线程池
by2n的专栏
05-05 1352
1、ExecutorService： 是一个接口，继承了Executor: public interface ExecutorService extends Executor { } 2、Executor： 而Executor亦是一个接口，该接口只包含了一个方法： void execute(Runnable command); 3、Executors： 该类是一个辅
关于动态线程池的实现
最新发布
weixin_63325479的博客
05-26 348
线程池中有几个核心参数， 核心线程数， 最大线程数， 阻塞队列， 拒绝策略， 备用线程生存时间等等。那是不是有一种方法， 能够通过动态调整线程池的方式， 来实现即时的参数调整，来让线程池更好的适配任务场景， 减少意外发生的风险和损失呢。listener： Thread Pool Config AdjustListener 线程池配置调整监听器： 用于上报线程池信息，和线程池参数信息，及时更新数据展示。创建 service类： 管理线程池： 获取线程池信息，获取线程池配置信息，更新线程池配置。
java线程池（一）之newFixedThreadPool
weixin_44613100的博客
06-07 2553
newFixedThreadPool 测试类 package com.thread.pool; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class TestFixedThreadPool { public static void main(String[] args) { /** * 调用方法 new ThreadPo
newFixedThreadPool、newSingleThreadExecutor、newCachedThreadPool
路在脚下
06-12 2228
public static ExecutorService newFixedThreadPool(int nThreads)     创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程。     在任意点，在大多数 nThreads 线程会处于处理任务的活动状态。如果在所有线程处于活动状态时提交附加任务，     则在有可用线程之前，附加任务将在队列中等待。如果在关闭前的执
java线程池newFixedThreadPool详解
yoyolity的专栏
04-10 8371
java线程池newFixedThreadPool详解
多线程与线程池技术详解（图书配套）
07-01
在实际开发中，Java的Executor框架提供了多种预定义的线程池，如`Executors.newFixedThreadPool`用于创建固定大小的线程池，`Executors.newSingleThreadExecutor`创建只有一个线程的线程池，以及`Executors....
Java基础之多线程
08-26
- `newFixedThreadPool(int nThreads)` 创建固定大小的线程池，线程数量固定，多余的线程会等待。 - `newSingleThreadExecutor()` 创建单线程的线程池，所有任务按照提交的顺序执行。 4. **线程控制**： - **...
Java多线程之异步Future机制的原理和实现共5页.p
11-22
Java多线程是并发编程中的核心概念，尤其在服务器端应用和大数据处理中扮演着重要角色。异步Future机制是Java多线程中用于提升效率和优化资源利用的一种设计模式，它允许我们在主线程中不等待子线程的执行结果，而是...
ThreadPoolExecutor 深入解析
weixin_57763462的博客
06-22 154
线程池的作用 ● 利用线程池管理并复用线程、控制最大并发数等 既然使用了线程池就需要确保线程池是在复用的，每次new一个线程池出来可能比不用线程池还糟糕。如果没有直接声明线程池而是使用其他人提供的类库来获得一个线程池，请务必查看源码，以确认线程池的实例化方式和配置是符合预期的。 ● 实现任务线程队列缓存策略和拒绝机制。 ● 实现某些与时间相关的功能，如定时执行、周期执行等 ● 隔离线程环境 比如，交易服务和搜索服务在同一台服务器上，分别开启两个线程池，交易线程的资源消耗明显要大；因此，通过配置独立的
java使用jdk的ThreadPoolExecutor线程池
sumengnan的博客
03-28 1458
一、使用Executors创建线程池（阿里不推荐使用此方法） Executors 是一个Java中的工具类。 常用方法： 1、newSingleThreadExecutor:创建一个单线程的线程池，用于需要保证顺序执行的逻辑，只有一个线程在执行。 2、newFixThreadExecutor:创建一个固定大小的线程池，用于已知并发压力下，对线程数做限制。 3、newCachedTh......
Java线程池Executor详解
老男孩的架构路
08-11 701
线程池的大小推荐为CPU数量 + 1，CPU数量可以根据Runtime.availableProcessors方法获取CPU数量 * CPU利用率 * (1 + 线程等待时间/线程CPU时间)将任务分为CPU密集型和IO密集型，然后分别使用不同的线程池去处理，从而使每个线程池可以根据各自的工作负载来调整推荐使用有界队列，有界队列有助于避免资源耗尽的情况发生。...
线程池种类与ThreadPoolExecutor的七大参数
weixin_46475802的博客
09-21 564
一、 线程池种类： 1、newFixedThreadPool： /** * Creates a thread pool that reuses a fixed number of threads * operating off a shared unbounded queue. At any point, at most * {@code nThreads} threads will be active processing tasks. * If addition
java线程池实现和线程池七大参数详解
白鸽
07-23 436
线程池 Callable接口 相比于runnable接口而言，callable可以抛出异常，并且返回返回值 callable接口基本使用 class Task implements Callable<String> { @Override public String call() throws Exception { System.out.println(Thread.currentThread().getName()); TimeUnit.S
Executors.newFixedThreadPool线程池的使用
u011191463的专栏
03-14 8245
ava5的线程池分好多种：具体的可以分为两类，固定尺寸的线程池、可变尺寸连接池。 　　在使用线程池之前，必须知道如何去创建一个线程池，在Java5中，需要了解的是java.util.concurrent.Executors类的API，这个类提供大量创建连接池的静态方法，是必须掌握的。
Java自带的线程池Executors.newFixedThreadPool
tengtianshan的专栏
10-24 3848
线程池的基本思想还是一种对象池的思想，开辟一块内存空间，里面存放了众多(未死亡)的线程，池中线程执行调度由池管理器来处理。当有线程任务时，从池中取一个，执行完成后线程对象归池，这样可以避免反复创建线程对象所带来的性能开销，节省了系统的资源。  　　在Java5之前，要实现一个线程池是相当有难度的，现在Java5为我们做好了一切，我们只需要按照提供的API来使用，即可享受线程池带来的极大便利。  ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值