java线程池

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

线程池


在这里插入图片描述

1. 为什么要用线程池？有什么优势？

在这里插入图片描述
例子:
10年前单核CPU电脑，假的多线程，像马戏团小丑玩多个球，CPU需要来回切换。现在是多核电脑，多个线程各自跑在独立的CPU上，不用切换效率高。

线程池的优势:

线程池做的工作只要是控制运行的线程数量，处理过程中将任务放入队列，然后在线程创建后启动这些任务，如果线程数量超过了最大数量，超出数量的线程排队等候，等其他线程执行完毕，再从队列中取出任务来执行。

它的主要特点为:

线程复用;控制最大并发数;管理线程。
第一:降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的销耗。
第二:提高响应速度。当任务到达时，任务可以不需要等待线程创建就能立即执行。
第三:提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会销耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

二级目录

三级目录

2.线程池如何使用：

线程池的三大方法：

在这里插入图片描述
在这里插入图片描述

1. Executors.newFixedThreadPool(5)

在这里插入图片描述

package JUCTest;

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

/**
 * 
 * @author fly
 *
 */
public class MyThreadPoolDemo26 {
	public static void main(String[] args) {
		ExecutorService threadPool = Executors.newFixedThreadPool(5);//五个工作线程的线程池（固定的）
		try {
			//模拟有10个顾客来银行办理业务，目前银行里面有5个工作人员提供服务
			for(int i = 1;i <= 10;i++) {
				threadPool.execute(()->{
					System.out.println(Thread.currentThread().getName()+"  办理业务");
				});
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			threadPool.shutdown();//关闭线程池
		}
	}
}
************************
pool-1-thread-3  办理业务
pool-1-thread-1  办理业务
pool-1-thread-4  办理业务
pool-1-thread-5  办理业务
pool-1-thread-2  办理业务
pool-1-thread-5  办理业务
pool-1-thread-4  办理业务
pool-1-thread-1  办理业务
pool-1-thread-3  办理业务
pool-1-thread-2  办理业务

2.Executors.newSingleThreadExecutor();//只有单个工作线程的线程池

在这里插入图片描述

ExecutorService threadPool = Executors.newSingleThreadExecutor();//只有单个工作线程的线程池
		
		try {
			//模拟有10个顾客来银行办理业务，目前银行里面有5个工作人员提供服务
			for(int i = 1;i <= 10;i++) {
				threadPool.execute(()->{
					System.out.println(Thread.currentThread().getName()+"  办理业务");
				});
				TimeUnit.MILLISECONDS.sleep(100L);
			}
			
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			threadPool.shutdown();//关闭线程池
		}
**********************************************************
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  办理业务

3.Executors.newCachedThreadPool()：//线程数课扩容的线程池(带缓存的线程池)

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

ExecutorService threadPool = Executors.newCachedThreadPool();//线程数课扩容的线程池(带缓存的线程池)
		
		try {
			//模拟有10个顾客来银行办理业务，目前银行里面有5个工作人员提供服务
			for(int i = 1;i <= 10;i++) {
				threadPool.execute(()->{
					System.out.println(Thread.currentThread().getName()+"  办理业务");
				});
				TimeUnit.MILLISECONDS.sleep(100L);
			}
			
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			threadPool.shutdown();//关闭线程池
		}

3.线程池的七大重要参数：

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
1、corePoolSize:线程池中的常驻核心线程数；
2、maximumPoolSize:线程池中能够容纳同时执行的最大线程数，此值必须大于等于1；
3、keepAliveTime:多余的空闲线程的存活时间当前池中线程数量超过corePoolSize时，当空闲时间达到keepAliveTime时，多余线程会被销毁直到只剩下corePoolSize个线程为止；
4、unit: keepAliveTime的单位；
5、workQueue:任务队列，被提交但尚未被执行的任务；
6、threadFactory:表示生成线程池中工作线程的线程工厂，用于创建线程，一般默认的即可；
7、handler:拒绝策略，表示当队列满了，并且工作线程大于等于线程池的最大线程数(maximumPoolSize）时如何来拒绝请求执行的runnable的策略；

/**
     * Creates a new {@code ThreadPoolExecutor} with the given initial
     * parameters.
     *
     * @param corePoolSize the number of threads to keep in the pool, even
     *        if they are idle, unless {@code allowCoreThreadTimeOut} is set
     * @param maximumPoolSize the maximum number of threads to allow in the
     *        pool
     * @param keepAliveTime when the number of threads is greater than
     *        the core, this is the maximum time that excess idle threads
     *        will wait for new tasks before terminating.
     * @param unit the time unit for the {@code keepAliveTime} argument
     * @param workQueue the queue to use for holding tasks before they are
     *        executed.  This queue will hold only the {@code Runnable}
     *        tasks submitted by the {@code execute} method.
     * @param threadFactory the factory to use when the executor
     *        creates a new thread
     * @param handler the handler to use when execution is blocked
     *        because the thread bounds and queue capacities are reached
     * @throws IllegalArgumentException if one of the following holds:<br>
     *         {@code corePoolSize < 0}<br>
     *         {@code keepAliveTime < 0}<br>
     *         {@code maximumPoolSize <= 0}<br>
     *         {@code maximumPoolSize < corePoolSize}
     * @throws NullPointerException if {@code workQueue}
     *         or {@code threadFactory} or {@code handler} is null
     */
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

4.线程池底层工作原理：

三大方法的底层：

Executors.newFixedThreadPool(5)：

在这里插入图片描述

Executors.newSingleThreadExecutor()：

在这里插入图片描述

Executors.newCachedThreadPool()：

在这里插入图片描述

本质

三个生成线程池的方法底层调用的都是同一个方法：new ThreadPoolExecutor();只是传的参数不同。
在这里插入图片描述

原理：

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
正在执行的线程数等于CorePooleSize，且阻塞队列也满员了，此时如果还有任务进来，name就会开始扩容，增加CorePooleSize的大小，扩容到CorePooleSize达到maxiumPoolSize，之后线程池不再开启新的线程，而是采用拒绝策略，不再允许新的任务使用线程池
扩容：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
1、在创建了线程池后，开始等待请求。
2、当调用execute()方法添加一个请求任务时，线程池会做出如下判断:
2.1如果正在运行的线程数量小于corePoolSize，那么马上创建线程运行这个任务;
2.2如果正在运行的线程数量大于或等于corePoolSize，那么将这个任务放入队列;
2.3如果这个时候队列满了且正在运行的线程数量还小于maximumPoo1Size，那么还是 要创建非核心线程立刻运行这个任务;
2.4如果队列满了且正在运行的线程数量大于或等于maximumPoolSize，那么线程池会 启动饱和拒绝策略来执行。
3、当一个线程完成任务时，它会从队列中取下一个任务来执行。
4、当一个线程无事可做超过一定的时间（keepAliveTime）时，线程会判断:
如果当前运行的线程数大于corePoolSize，那么这个线程就被停掉。所以线程池的所有任务完成后，它最终会收缩到corePoolSize的大小。

5.如何手撕线程池？以及定义参数？

如何创建线程池：

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

最大执行任务的数量：maximumPoolSize+阻塞队列的长度
超过则抛出异常：拒绝执行异常：java.util.concurrent.RejectedExecutionException

代码：

public class MyThreadPoolDemo26 {
	
	public static void main(String[] args) {
		System.out.println("CPU处理器数（内核）："+Runtime.getRuntime().availableProcessors());
		ExecutorService threadPool = new ThreadPoolExecutor(2, //核心数
															5, //最大线程数     CPU密集型电脑  一般设置值为：比电脑核数多1或者2   I/O密集型电脑：一般设置为：1除以核数除以阻塞系数 
															2L, //扩容线程的最大活跃时间（等待时间）
															TimeUnit.SECONDS, //时间格式
															new LinkedBlockingDeque<Runnable>(3),//阻塞队列//如果不指名队列大小，则默认Integer.MAXVALUE
															Executors.defaultThreadFactory(),//线程工厂
															new ThreadPoolExecutor.DiscardOldestPolicy());//拒绝策略
		try {
			//模拟有10个顾客来银行办理业务，目前银行里面有5个工作人员提供服务
			for(int i = 1;i <= 10;i++) {
				threadPool.execute(()->{
					System.out.println(Thread.currentThread().getName()+"  办理业务");
				});
//				TimeUnit.MILLISECONDS.sleep(100L);
			}
			
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			threadPool.shutdown();//关闭线程池
		}
		
		
		
	}
}

6.拒绝策略：

在这里插入图片描述
在这里插入图片描述

1.AbortPolicy()：默认策略。

在这里插入图片描述
在这里插入图片描述

2.CallerRunsPolicy():

在这里插入图片描述
在这里插入图片描述

3.DiscardPolicy():

十个任务，抛弃了两个，只执行了八个（最大任务量）
在这里插入图片描述
在这里插入图片描述

4.DiscardOldestPolicy():

抛弃等待队列中等待时间最长的任务
在这里插入图片描述
在这里插入图片描述

代码：

public class MyThreadPoolDemo26 {
	
	public static void main(String[] args) {
		System.out.println("CPU处理器数（内核）："+Runtime.getRuntime().availableProcessors());
		ExecutorService threadPool = new ThreadPoolExecutor(2, //核心数
															5, //最大线程数     CPU密集型电脑  一般设置值为：比电脑核数多1或者2   I/O密集型电脑：一般设置为：1除以核数除以阻塞系数 
															2L, //扩容线程的最大活跃时间（等待时间）
															TimeUnit.SECONDS, //时间格式
															new LinkedBlockingDeque<Runnable>(3),//阻塞队列//如果不指名队列大小，则默认Integer.MAXVALUE
															Executors.defaultThreadFactory(),//线程工厂
															new ThreadPoolExecutor.DiscardOldestPolicy());//拒绝策略（可以修改）
															//new ThreadPoolExecutor.AbortPolicy();
															//new ThreadPoolExecutor.CallerRunsPolicy();
															//new ThreadPoolExecutor.DiscardPolicy();
		try {
			//模拟有10个顾客来银行办理业务，目前银行里面有5个工作人员提供服务
			for(int i = 1;i <= 10;i++) {
				threadPool.execute(()->{
					System.out.println(Thread.currentThread().getName()+"  办理业务");
				});
//				TimeUnit.MILLISECONDS.sleep(100L);
			}
			
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			threadPool.shutdown();//关闭线程池
		}
		
		
	}
		
}
GodOfCode_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线程池使用
天才周的博客
08-21 212
线程池： 多线程技术主要解决处理器单元内多个线程执行的问题，它可以显著减少处理器单元的闲置时间，增加处理器单元的吞吐能力。 假设一个服务器完成一项任务所需时间为：T1 创建线程时间，T2 在线程中执行任务的时间，T3 销毁线程时间。 如果：T1 + T3 远大于 T2，则可以采用线程池，以提高服务器性能。 一个线程池包括以...
Java 线程池框架
08-31
Java线程池框架是Java并发处理的核心工具，它允许开发者高效地管理多个并发任务，避免了频繁创建和销毁线程的开销。线程池通过维护一组可重用的线程来提高系统的性能和响应性。本文将深入探讨Java线程池的结构、常见...
线程池的使用
人生不设限，高飞吧~
12-03 4700
在Java5之后，并发线程这块发生了根本的变化，最重要的莫过于新的启动、调度、管理线程的一大堆API了。在Java5以后，通过Executor来启动线程比用Thread的start（）更好。在新特征中，可以很容易控制线程的启动、执行和关闭过程，还可以很容易使用线程池的特性。 　　一、创建任务 　　任务就是一个实现了Runnable接口的类。 　　创建的时候实run方法即可。
线程池的使用-线程池的使用
afssa的博客
08-18 226
线程池的使用 线程资源不应该直接使用，不应该在程序中显式使用，而应该由线程池提供 1、使用线程池的优势 （1）使用new Thread 创建线程有较大的弊端 1 .每次使用线程都需要new Thread（）创建对象性能较差 2 .线程缺少管理，可能会无限创建线程，导致系统死机及oom 3.线程功能单一，缺少其他设置 （2）线程池的优势 （1）、大幅度降低资源消耗，复用线程池中线程，避免线程创建和销毁的操作 节约时间和间隔； （2）、提高系统响应速度，当有任务到达时，通过复用已存在的线程，无需等待新线程的创.
谈谈Java 线程池
09-07
Java线程池是一种高效利用系统资源、管理和控制并发的重要工具。在Java中，线程池的概念借鉴了数据库连接池的思想，旨在通过复用已存在的线程来减少创建和销毁线程的开销，从而提高程序的运行效率。线程池不仅能够...
JAVA线程池原理实例详解
08-26
JAVA线程池原理实例详解 JAVA线程池是java中的一种高效的线程管理机制，它可以控制线程的创建、销毁和复用，从而提高系统的性能和可靠性。下面我们将详细介绍JAVA线程池的原理、创建、使用方法及相关注意事项。 一...
java线程池封装j
08-13
Java线程池是一种高效管理线程的技术，它允许开发者预定义一组线程，根据任务的需要灵活调度，而不是每次需要执行任务时都创建新的线程。这种设计模式大大提高了系统的性能，减少了系统资源的消耗，特别是在高并发...
JAVA线程池例子
04-16
Java线程池是一种高效管理线程资源的技术，它允许开发者创建一组可重用的工作线程，从而避免频繁地创建和销毁线程带来的性能开销。线程池在Java中主要通过`java.util.concurrent`包中的`ExecutorService`接口及其...
java 线程池嵌套线程池
最新发布
04-25
Java线程池是一种用于管理和复用线程的机制，它可以提高多线程应用程序的性能和效率。线程池中的线程可以被重复使用，避免了频繁创建和销毁线程的开销。 在Java中，线程池可以通过`ExecutorService`接口来创建和...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值