一个企业网站文章多少适合,网店关键词怎么优化,网页设计实训报告小结,海口网站建设发布Day32 线程池
1.引入 一个线程完成一项任务所需时间为#xff1a; 创建线程时间 - Time1线程中执行任务的时间 - Time2销毁线程时间 - Time3 2.为什么需要线程池(重要) 线程池技术正是关注如何缩短或调整Time1和Time3的时间#xff0c;从而提高程序的性能。项目中可以把Time…Day32 线程池
1.引入 一个线程完成一项任务所需时间为 创建线程时间 - Time1线程中执行任务的时间 - Time2销毁线程时间 - Time3 2.为什么需要线程池(重要) 线程池技术正是关注如何缩短或调整Time1和Time3的时间从而提高程序的性能。项目中可以把Time1T3分别安排在项目的启动和结束的时间段或者一些空闲的时间段线程池不仅调整Time1Time3产生的时间段而且它还显著减少了创建线程的数目提高线程的复用率系统启动一个新线程的成本是比较高的因为涉及与操作系统的交互在这种情形下使用线程池可以很好地提高性能尤其是当程序中需要创建大量生存期很短暂的线程时优先考虑使用线程池 3.Java提供的线程池(了解即可) 一般不会使用这个局限性太多 ExecutorService线程池的接口 Executors创建各种线程池的工具类 public class Test {public static void main(String[] args) {//创建单个线程的线程池//ExecutorService pool Executors.newSingleThreadExecutor();//创建指定线程的线程池//ExecutorService pool Executors.newFixedThreadPool(3);//创建可缓存线程的线程池自动回收60s闲置线程ExecutorService pool Executors.newCachedThreadPool();//循环创建任务对象并提交给线程池for (int i 1; i 100; i) {//创建任务对象Task task new Task(i);//提交任务pool.execute(task);}//关闭线程池pool.shutdown();}
}class Task implements Runnable{private int i;public Task(int i) {this.i i;}Overridepublic void run() {System.out.println(Thread.currentThread().getName() 处理了第 num 个任务);}
}4.深入源码 ExecutorService pool Executors.newSingleThreadExecutor(); ExecutorService pool Executors.newFixedThreadPool(3); ExecutorService pool Executors.newCachedThreadPool(); 三种线程池底层都是ThreadPoolExecutor类的对象 -- 分析ThreadPoolExecutor类的构造方法源码--------------------------------
public ThreadPoolExecutor(int corePoolSize, ------------- 核心线程数量 int maximumPoolSize, ------------- 最大线程数量 long keepAliveTime, ------------- 闲置时间作用于核心线程数与最大线程数之间的线程TimeUnit unit, ------------- keepAliveTime的时间单位(可以是毫秒、秒....)BlockingQueueRunnable workQueue, -- 任务队列ThreadFactory threadFactory, -------- 线程工厂RejectedExecutionHandler handler ---- 达到了线程界限和队列容量时的处理方案(拒绝策略)
) {}
执行步骤:1.创建线程池后2.任务提交后查看是否有核心线程3.1 没有 - 就创建核心线程 - 执行任务 - 执行完毕后又回到线程池中3.2 有 - 查看是否有闲置核心线程4.1 有 - 执行任务 - 执行完毕后又回到线程池4.2 没有 - 查看当前核心线程数是否核心线程数量5.1 否 - 就创建核心线程 - 执行任务 - 执行完毕后又回到线程池中5.2 是 - 查看任务列表是否装载满6.1 没有 - 就放入列表中等待出现闲置线程6.2 装满 - 查看是否有普通线程(核心线程数到最大线程数量之间的线程)7.1 没有 - 就创建普通线程 - 执行任务 - 执行完毕后又回到线程池中7.2 有 - 查看是否有闲置普通线程7.1.1 有 - 执行任务 - 执行完毕后又回到线程池中7.1.2 没有 - 查看现在所有线程数量是否为最大线程数8.1 是 - 执行处理方案默认处理抛出异常8.2 否 -就创建普通线程- 执行任务 - 执行完毕后又回到线程池中
注1.为了更好的理解在这里区分核心线程和普通线程实际上区分的这么清楚都是线程2.默认的处理方案就是抛出RejectedExecutionException-- 分析单个线程的线程池的源码 --------------------------------
ExecutorService pool Executors.newSingleThreadExecutor();
new ThreadPoolExecutor(1, -- 核心线程数量 1, -- 最大线程数量 0L, -- 闲置时间TimeUnit.MILLISECONDS, -- 时间单位(毫秒)new LinkedBlockingQueueRunnable() -- 无界任务队列可以无限添加任务内存溢出问题
)
-- 分析指定线程的线程池的源码 --------------------------------
ExecutorService pool Executors.newFixedThreadPool(3);
new ThreadPoolExecutor(nThreads, -- 核心线程数量 nThreads, -- 最大线程数量 0L, -- 闲置时间TimeUnit.MILLISECONDS, -- 时间单位(毫秒)new LinkedBlockingQueueRunnable()-- 无界任务队列可以无限添加任务内存溢出问题
)
-- 创建可缓存线程的线程池 -----------------------------------
new ThreadPoolExecutor(0, -- 核心线程数量 Integer.MAX_VALUE,-- 最大线程数量 60L, -- 闲置时间TimeUnit.SECONDS, -- 时间单位(秒)new SynchronousQueueRunnable() -- 直接提交队列(同步队列)没有容量队列最大线程数量是21亿多太大了总结核心线程满载 - 任务队列 - 普通线程 - 拒绝策略 5.任务队列详解
队列名称详解LinkedBlockingQueue无界任务队列使用无界任务队列线程池的任务队列可以无限制的添加新的任务而线程池创建的最大线程数量就是你corePoolSize设置的数量也就是说在这种情况下maximumPoolSize这个参数是无效的哪怕你的任务队列中缓存了很多未执行的任务当线程池的线程数达到corePoolSize后就不会再增加了若后续有新的任务加入则直接进入队列等待当使用这种任务队列模式时一定要注意你任务提交与处理之间的协调与控制不然会出现队列中的任务由于无法及时处理导致一直增长直到最后资源耗尽的问题SynchronousQueue 同步任务队列 直接提交任务队列使用直接提交任务队列队列没有容量每执行一个插入操作就会阻塞需要再执行一个删除操作才会被唤醒反之每一个删除操作也都要等待对应的插入操作。 任务队列为SynchronousQueue创建的线程数大于maximumPoolSize时直接执行了拒绝策略抛出异常。 使用SynchronousQueue队列提交的任务不会被保存总是会马上提交执行。如果用于执行任务的线程数量小于maximumPoolSize则尝试创建新的线程如果达到maximumPoolSize设置的最大值则根据你设置的handler执行拒绝策略。因此这种方式你提交的任务不会被缓存起来而是会被马上执行在这种情况下你需要对你程序的并发量有个准确的评估才能设置合适的maximumPoolSize数量否则很容易就会执行拒绝策略ArrayBlockingQueue有界任务队列使用有界任务队列若有新的任务需要执行时线程池会创建新的线程直到创建的线程数量达到corePoolSize时则会将新的任务加入到等待队列中。若等待队列已满即超过ArrayBlockingQueue初始化的容量则继续创建线程直到线程数量达到maximumPoolSize设置的最大线程数量若大于maximumPoolSize则执行拒绝策略。在这种情况下线程数量的上限与有界任务队列的状态有直接关系如果有界队列初始容量较大或者没有达到超负荷的状态线程数将一直维持在corePoolSize以下反之当任务队列已满时则会以maximumPoolSize为最大线程数上限。PriorityBlockingQueue优先任务队列使用优先任务队列它其实是一个特殊的无界队列它其中无论添加了多少个任务线程池创建的线程数也不会超过corePoolSize的数量只不过其他队列一般是按照先进先出的规则处理任务而PriorityBlockingQueue队列可以自定义规则根据任务的优先级顺序先后执行。 对优先队列的使用说明 除了第一个任务直接创建线程执行外其他的任务都被放入了优先任务队列按优先级进行了重新排列执行且线程池的线程数一直为corePoolSize也就是只有一个。 5.1 无界队列 理解这个队列没有上线 继承关系LinkedBlockingQueue - AbstractQueue - AbstractCollection 小结 1.LinkedBlockingQueue是Collection集合家族的一员 2.Collection集合家族List、Set、Queue 3.LinkedBlockingQueue数据结构单向链表 缺点LinkedBlockingQueue可能造成内存溢出 public class Test01 {public static void main(String[] args) throws InterruptedException {//创建无界队列LinkedBlockingQueueString queue new LinkedBlockingQueue();//添加元素queue.put(aaa);queue.put(bbb);queue.put(ccc);queue.put(ddd);queue.put(eee);queue.put(fff);//删除元素queue.remove(ccc);//遍历队列IteratorString it queue.iterator();while (it.hasNext()) {String string it.next();System.out.println(string);}}
}public class Task implements Runnable,ComparableTask{private int priority;//优先级别public Task(int priority) {this.priority priority;}Overridepublic void run() {System.out.println(任务被处理了);}//当前对象和其他对象做比较当前优先级大就返回-1优先级小就返回1,值越小优先级越高Overridepublic int compareTo(Task o) {return Integer.compare(this.priority, o.priority);}public int getPriority() {return priority;}
}5.2 有界队列 继承关系ArrayBlockingQueue - AbstractQueue - AbstractCollection 小结 1.ArrayBlockingQueue数据结构一维数组 缺点不能有效控制项目中的线程目数 public class Test02 {public static void main(String[] args) throws InterruptedException {//创建有界队列ArrayBlockingQueueString queue new ArrayBlockingQueue(6);//添加元素queue.put(aaa);queue.put(bbb);queue.put(ccc);queue.put(ddd);queue.put(eee);queue.put(fff);//删除元素queue.remove(ccc);//遍历队列IteratorString it queue.iterator();while (it.hasNext()) {String string it.next();System.out.println(string);}}
}5.3 优先队列 继承关系ArrayBlockingQueue - AbstractQueue - AbstractCollection ArrayBlockingQueue数据结构一维数组 public class Test03 {public static void main(String[] args) throws InterruptedException {//创建优先队列PriorityBlockingQueueTask queue new PriorityBlockingQueue();//无参构造底层使用的是元素的内置比较器//添加元素queue.add(new Task(3));queue.add(new Task(1));queue.add(new Task(4));queue.add(new Task(2));//遍历取出队列while(!queue.isEmpty()){//删除第一元素Task poll queue.poll();System.out.println(poll.getPriority());} }
}6.拒绝策略 ThreadPoolExecutor自带的拒绝策略有四种都实现了RejectedExecutionHandler接口 比如new ThreadPoolExecutor.AbortPolicy() 拒绝策略解释AbortPolicy当有任务添加到线程池被拒绝时会抛出RejectedExecutionException异常 线程池默认的拒绝策略。必须处理好抛出的异常否则会打断当前的执行流程影响后续的任务执行。DiscardPolicy当有任务添加到线程池被拒绝时直接丢弃其他啥都没有CallerRunsPolicy当有任务添加到线程池被拒绝时线程池会将被拒绝的任务添加到线程池正在运行的线程中去运行。 一一般并发比较小性能要求不高不允许失败。但是由于调用者自己运行任务如果任务提交速度过快可能导致程序阻塞性能效率上必然的损失较大DiscardOledestPolicy当有任务添加到线程池被拒绝时线程池会丢弃阻塞队列中末尾的任务最老的任务然后将被拒绝的任务添加到末尾。 如果项目中有允许丢失任务的需求可以使用
6.1 自定义拒绝策略(实现RejectedExecutionHandler接口)
public class Test {public static void main(String[] args) {ThreadPoolExecutor pool new ThreadPoolExecutor(1, 1, 1000, TimeUnit.MILLISECONDS, new ArrayBlockingQueue(1), Executors.defaultThreadFactory(), new RejectedExecutionHandler() {Overridepublic void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {System.out.println(r.toString()执行了拒绝策略);}});for (int i 1; i 10; i) {pool.execute(new Task());}pool.shutdown();}
}
class Task implements Runnable{Overridepublic void run() {try {Thread.sleep(1000);System.out.println(Thread.currentThread().getName());} catch (InterruptedException e) {e.printStackTrace();}}
}7.自定义线程池原因重要 为什么不使用java自带的线程池而去自定义线程池 在《阿里巴巴java开发手册》中指出了线程资源必须通过线程池提供不允许在应用中自行显示的创建线程这样一方面使线程的创建更加规范可以合理控制开辟线程的数量另一方面线程的细节管理交给线程池处理优化了资源的开销。而线程池不允许使用Executors去创建而要通过ThreadPoolExecutor方式这一方面是由于jdk中Executor框架虽然提供了如newFixedThreadPool()、newSingleThreadExecutor()、newCachedThreadPool()等创建线程池的方法但都有其局限性不够灵活而且有资源耗尽的风险OOM - Out Of Memory 。 一般我们创建线程池时为防止资源被耗尽任务队列都会选择创建有界任务队列但这种模式下如果出现任务队列已满且线程池创建的线程数达到你设置的最大线程数时这时就需要你指定ThreadPoolExecutor的RejectedExecutionHandler参数即合理的拒绝策略来处理线程池超载的情况 7.1 自定义线程池 七大属性要记住 前提学习线程池中如何创建线程 线程池中线程就是通过ThreadPoolExecutor中的ThreadFactory线程工厂创建的。那么通过自定义ThreadFactory可以按需要对线程池中创建的线程进行一些特殊的设置如命名、优先级等 public class Test01 {public static void main(String[] args) {ThreadPoolExecutor pool new ThreadPoolExecutor(5, //核心线程数20, //最大线程数60, //闲置时间TimeUnit.SECONDS, //时间单位new ArrayBlockingQueue(30), //任务队列 -- 有界队列new ThreadFactory() {//自定义线程工厂private int num 1;Overridepublic Thread newThread(Runnable r) {Thread t new Thread(r);t.setName(自定义线程池中的线程num);t.setPriority(Thread.MAX_PRIORITY);num;return t;}}, new RejectedExecutionHandler() {//自定义拒绝策略Overridepublic void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {System.out.println(任务被拒绝了~~~);}});for (int i 1; i 100; i) {Task task new Task(i);pool.execute(task);}pool.shutdown();}
}public class Task implements Runnable{private int num;public Task(int num) {this.num num;}Overridepublic void run() {System.out.println(Thread.currentThread().getName() 处理了第 num 个任务);}}
7.2 自己写一个线程池 自定义线程池类 //自己写的线程池
public class FastThreadPool extends ThreadPoolExecutor{public FastThreadPool(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,BlockingQueueRunnable workQueue) {super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, new FastThreadFactory(), new FastRejectedExecutionHandler());}public FastThreadPool(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,BlockingQueueRunnable workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler) {super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, handler);}//七大属性记住重要Overrideprotected void beforeExecute(Thread t, Runnable r) {System.out.println(线程执行任务之前调用 -- r);}Overrideprotected void afterExecute(Runnable r, Throwable t) {System.out.println(线程执行任务之后调用 -- r);}Overrideprotected void terminated() {System.out.println(线程池关闭时调用);}//自定义线程工厂实现ThreadFactory接口private static class FastThreadFactory implements ThreadFactory{private int num;//线程编号Overridepublic Thread newThread(Runnable r) {Thread t new Thread(r);t.setName(自定义线程池中的线程num);t.setPriority(Thread.MAX_PRIORITY);num;return t;}}//自定义拒绝策略实现RejectedExecutionHandlerprivate static class FastRejectedExecutionHandler implements RejectedExecutionHandler{Overridepublic void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {System.out.println(任务被拒绝了~~~);}}} 任务类 public class Task implements Runnable{private int num;public Task(int num) {this.num num;}Overridepublic void run() {System.out.println(Thread.currentThread().getName() 处理了第 num 个任务);}Overridepublic String toString() {return 任务 num;}
} 测试类 public class Test01 {public static void main(String[] args) {FastThreadPool pool new FastThreadPool(5, 20, 60, TimeUnit.SECONDS, new ArrayBlockingQueue(30));for (int i 1; i 100; i) {Task task new Task(i);pool.execute(task);}//设置为true后闲置时间一旦到达核心线程也会被销毁//经验我们一般不会回收核心线程因为设置回收后线程池中的线程有可能为0这样就没有线程复用率的说法了//pool.allowCoreThreadTimeOut(true);pool.shutdown();}
} 面试题线程池中核心线程会被回收吗 当线程池调用了allowCoreThreadTimeOut(true);时核心线程会被回收 但是一般不会调用该方法也就是说项目中线程池中的核心线程不要设计被回收因为如果线程池中线程全部都回收了就没有线程复用率这个说法 核心线程宁可闲置也不回收 7.3 ThreadPoolExecutor扩展 ThreadPoolExecutor扩展主要是围绕beforeExecute()、afterExecute()和terminated()三个方法的重写 通过这三个方法我们可以监控每个任务的开始和结束时间或者其他一些功能。下面我们可以通过代码实现一下 方法解释beforeExecute线程池中任务运行前执行afterExecute线程池中任务运行完毕后执行terminated线程池退出后执行 上面自己写的自定义线程池里有相关使用 8.线程池线程数量 实际工作中使用 sysbench多线程性能测试工具 重要因为七大属性中的核心线程数最大线程数闲置时间不能随便乱写一个数字上去而是要进行相关测试才能得出数据 9.带有返回值的任务类(实现 Callable接口) 注意带有返回值的任务类和线程池一起使用 需求计算任务一个包含了2万个整数的数组分拆了多个线程来进行并行计算最后汇总出计算的结果。 public class Test01 {public static void main(String[] args) throws InterruptedException, ExecutionException {//创建数组int[] arr new int[20000];//初始化数组数据 -- {1,2,3,....,20000}for (int i 0; i arr.length; i) {arr[i] i1;}//创建线程池FastThreadPool pool new FastThreadPool(4, 4, 0, TimeUnit.SECONDS, new ArrayBlockingQueue(5));//创建任务Task task1 new Task(arr, 0, 5000,1);Task task2 new Task(arr, 5000, 10000,2);Task task3 new Task(arr, 10000, 15000,3);Task task4 new Task(arr, 15000, 20000,4);//提交任务任务完成后会返回Future对象Future对象里存储了任务的返回值数据FutureInteger future1 pool.submit(task1);FutureInteger future2 pool.submit(task2);FutureInteger future3 pool.submit(task3);FutureInteger future4 pool.submit(task4);//合并任务返回值System.out.println(future1.get() future2.get() future3.get() future4.get());pool.shutdown();}
} 带返回值的任务类 public class Task implements CallableInteger{private int[] arr;private int startIndex;private int endIndex;private int num;public Task(int[] arr, int startIndex, int endIndex,int num) {this.arr arr;this.startIndex startIndex;this.endIndex endIndex;this.num num;}//理解线程抢到CPU资源后才会调用call方法call方法相当于Runnable接口中的run方法Overridepublic Integer call() throws Exception {int sum 0;for (int i startIndex; i endIndex; i) {sum arr[i];System.out.println(任务 num);}return sum;}}
总结 1.Java自带的线程池 单个线程的线程池 指定线程个数的线程池 可缓存的线程池 延迟任务的线程池 2.线程池的7大参数 核心线程数 最大线程数 任务队列有界、无界、同步、优先队列 拒绝策略 闲置时间 时间单位 线程工厂 3.线程池的调用步骤核心线程、任务队列、普通线程、拒绝策略 4.任务队列及底层原理有界、无界、同步、优先队列 5.自定义线程池 自定义线程工厂 自定义拒绝策略 6.带有返回值的任务类 --Callable
