线程池

我有一个这样的线程池的场景，相信很多人都遇到过： 1，每个用户都可以添加多个任务； 2，有很多的用户和很多的任务； 3，每个用户添加的任务必须有序串行执行，即在同一时刻不能有同时执行一个用户的两个任务； 4，实时性：只要线程池线程有空闲的，那么用户提交任务后必须立即执行；尽可能提高线程的利用率。 代码比较简洁，基本满足上述要求： public class SerialThreadExecutor { private Executor executor; private ConcurrentMap<Object, SequentialJob> serialJobs = new ConcurrentHashMap<Object, SequentialJob>(); public SerialThreadExecutor(Executor executor) { super(); this.executor = executor; } public void executeSerially(Object key, Runnable r) { SequentialJob job = serialJobs.get(key); if (job == null) { job = new SequentialJob(key); SequentialJob oldJob = serialJobs

多进程 VS 多线程 VS 线程池 VS EventLoop 在现在的编程过程中，经常听到多进程，多线程，线程池，EventLoop 的概念，选择一个正确的驱动模型，有助于提升代码的性能。 注：本文仅仅讨论并发的情况。 进程和线程 进程：操作系统中 资源管理对象 ，管理虚拟内存，文件句柄，线程等资源，但是 进程不是执行单元 。 线程： 具体的执行单元 。CPU是实际的物理执行单元，通过 寄存器 可以控制CPU执行的代码以及状态。而线程就是包含了一个任务的CPU上下文（寄存器），任务状态（就绪|阻塞|运行），所属用户等信息的对象。操作系统接收到时间中断（INT）后， 通过轮转线程中的CPU上下文（寄存器）信息，实现了多任务的轮转 。 多进程 多进程：针对并发请求，一个请求开启一个进程进行处理。早起CGI就是这么干的。 代表：早期PHP，CGI类 优点： 一个业务进程奔溃不影响另外一个业务进程，从操作系统层面上隔离业务执行 如果进程采用Socket之类的RPC调用，那么非常容易部署到网络环境上 缺点： RPC调用比较难以编写 频繁的开启和关闭进程，性能比较差 不允许内存共享（排除内核支持情况） 多线程 多线程：针对不同的业务逻辑，并发的开启多个线程进行执行。 代表：早期 Tomcat Bio模型 优点： 内存是共享的 编写并发模型比较方便 有效的利用多核CPU 缺点： 并发量过大的时候

一、线程池 1、线程池的概念与Executors类的应用 > 创建固定大小的线程池 > 创建缓存线程池 > 创建单一线程池( 如何实现线程死掉后重启？ ) 2、关闭线程池 > shutdown与shutdownNow的比较 前者是任务执行完毕即关闭程序，或者表示立即关闭而不会关心任务是否已经完成。 3、用线程池启动定时器 > 调用ScheduledExecutorService的schedule方法，返回的ScheduleFuture对象可以取消任务 > 支持间隔重复任务的定时方式，不直接支持绝对定时方式，需要转换成相对时间方式 二、代码描述 1、ThreadPoolTest.java 常见几种线程池类型 /** * @Title: ThreadPoolTest.java * @Package com.lh.threadtest.t8 * @Description: TODO * @author Liu * @date 2018年1月17日 下午2:17:40 * @version V1.0 */ package com.lh.threadtest.t8; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent

v 多线程实现手段： (1)、继承Thread类 (2)实现Runable接口 (3)使用线程池 v 线程控制在那个包： java.util.concurrent。 (1) 提供了线程的运行、 (2) 线程池的创建、 (3) 线程生命周期的控制 v 线程池 java.util.concurrent.Executors创建线程池的四种方法 (1) newCachedThreadPool创建 非固定数量 , 可缓存的线程池 ,若线程池超过处理需要,可灵活回收空线程,若没有线程可回收,则建新 (2) newFixedThreadPool 固定线程池 ,底层是无界队列,可 控制最大并发数 ,超出的线程会在队列中等待 (3) newScheduledThreadPool 定时执行线程池 , 支持定时及周期性任务执行 (4) newSingleThreadExecutor单线程化的线程池,只会用唯一的工作线程来执行任务, 保证所有任务按照顺序执行 。 如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它 v Sleep()和 Wait()的区别 (1) Sleep()是Thread的方法，Wait()是Object的方法 (2) Sleep( 休眠 )暂停指定时间，执行是CPU让出来，但对象锁继续保持。休眠时间到之后自动回复就绪状态。Wait( 线程暂停执行 )当前线程放弃对象锁

public class MyRunable implements Runnable { @Override public void run () { for ( int x = 0 ; x < 100 ; x++) { System. out .println(Thread. currentThread ().getName() + ":" + x) ; } } } /** * 线程池的好处 : 线程池里的每一个线程代码结束后，并不会死亡，而是再次回到线程池中称为空闲状态，等待下一个对象来使用 * 如何实现线程的代码呢？ * A: 创建一个线程池对象，控制要创建几个线程对象 * public static ExecutorService newFixedThreadPool(int nThreads) * B: 这种线程池的线程可以执行 : * 可以执行 Runnable 对象或者 Callable 对象代表的线程 * 做一个类实现 Runnable 接口 * C: 调用如下方法即可 * Future <?> submit(Runnable task) * <T> Future <T> submit(Callable <T> task) * D: 我就要结束，可以吗？ 可以 * */ public class ExecutorsDemo { public static void

ExecutorService exe = Executors. newFixedThreadPool (4); ThreadPoolExecutor(4,4,0L, TimeUnit.MILLSECONDS, new LinkedBlockingQueue<Runnable>()); 结果： 1. 当开始运行时，线程池中的线程小于 corePoolSize 时，开启新的线程 ; 2. 当新的任务添加，线程池线程超过 corePoolSize 时，任务放在队列中； 3. 实际运行的线程最大不超过 maximumPoolSize ，即 4 ； 4. queueSize=getTaskCount-getCompletedTaskCount-getActiveCount ； 5. 提交的任务不一定是按提交顺序完成运行，如提交顺序是 id_1,id_2,id_3,id_4 ，可能id_ 4 最先完成执行。 ExecutorService exe = Executors. newCachedThreadPool (); ThreadPoolExecutor(0, Integer. MAX_VALUE , 60L, TimeUnit. SECONDS , new SynchronousQueue<Runnable>()); 结果 ： 1. 当新的任务添加，线程池中无空闲线程时，创建新的线程

工作中遇到了消息队列的发送，之前都是用数据库作为中转和暂存的。这次考虑用多线程的方式进行消息的发送，于是学习了一下线程池的应用。说实话，实践中对Java高级特性的应用真的不多，对多线程的理解也就一直停留在理论层面。借着实践的机会好好整理一下。 准备从以下几个方面总结： 线程池的使用 消息队列——生产者消费者模式 定时任务Quartz原理 线程池的大小、队列大小设置 这个部分是有关线程池的使用： 1. 为什么要用线程池？ 在Java中，如果每当一个请求到达就创建一个新线程，开销是相当大的。在实际使用中，每个请求创建新线程的服务器在创建和销毁线程上花费的时间和消耗的系统资源，甚至可能要比花在实际处理实际的用户请求的时间和资源要多的多。除了创建和销毁线程的开销之外，活动的线程也需要消耗系统资源。如果在一个JVM中创建太多的线程，可能会导致系统由于过度消耗内存或者“切换过度”而导致系统资源不足。为了防止资源不足，服务器应用程序需要一些办法来限制任何给定时刻处理的请求数目，尽可能减少创建和销毁线程的次数，特别是一些资源耗费比较大的线程的创建和销毁，尽量利用已有对象来进行服务，这就是“池化资源”技术产生的原因。 线程池主要用来解决线程生命周期开销问题和资源不足问题，通过对多个任务重用线程，线程创建的开销被分摊到多个任务上了，而且由于在请求到达时线程已经存在，所以消除了创建所带来的延迟。这样

前言 只有光头才能变强。 文本已收录至我的GitHub精选文章，欢迎Star ： https://github.com/ZhongFuCheng3y/3y 在上周总结了一篇「工作中常用到的Java集合类」，反响还不错。这周来写写Java另一个重要的知识点：「 多线程 」 多线程大家在初学的时候，对这个知识点应该有不少的疑惑的。我认为主要原因有两个： 多线程在初学的时候不太好学，并且一般写项目的时候也很少用得上（至少在初学阶段时写的项目基本不需要自己创建线程）。 多线程的知识点在面试经常考，多线程所涉及的知识点非常多，难度也不低。 这就会给人带来一种感觉「 这破玩意涉及的东西是真的广，平时也不怎么用，怎么面试就偏偏爱问这个鬼东西 」 不多BB，我要开始了。 为什么使用多线程？ 首先，我们要明确的是「为什么要使用多线程」，可能有人会认为「 使用多线程就是为了加快程序运行的速度啊 」。如果你是这样回答了，那面试官可能会问你「那多线程是怎么加快程序运行速度的？」 于我的理解：使用多线程最主要的原因是 提高系统的资源利用率 。 现在CPU基本都是多核的，如果你只用单线程，那就是只用到了一个核心，其他的核心就相当于空闲在那里了。 厕所的坑位有5个，如果只用一个坑位，那不是很亏？比如现在我有5个人要上厕所。 在单线程的时候：进去一个人解决要10分钟，然后后面的人都得等一个坑位

#一 先说一些关键性的东西。 当 PoolSize<CorePoolSize 时增加 PoolSize; 当队列大小 < QueueCapacity 时由当前线程池执行 workQueue.offer(command)； 当 PoolSize >= CorePoolSize && PoolSize<MaxPoolSize 时，且队列大小 >=QueueCapacity 时，新增线程数量，但大小必须 < MaxPoolSize. KeepAliveTime 是线程是否退出的衡量时间，但核心线程是否退出还要看 allowCoreThreadTimeOut else if (poolSize > corePoolSize || allowCoreThreadTimeOut) r = workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS); #二 下面是重点，Spring 中 ThreadPoolTaskExcutor ##1 异步配置类，为下边的异步注入提供配置 @EnableAsync @Configuration @ComponentScan("org.sselab.conf") public class TaskConfig implements AsyncConfigurer { @Override public Executor

关于spring的ThreadPoolTaskExecutor： 他的一个应用场景就是调第三方的接口的时候，有可能第三方响应非常缓慢，这个时候最好的办法就是能有个最大的等待时间，不然自己的程序会一直卡死，阻塞，最好的办法就是使用 ThreadPoolTaskExecutor.excute(new Runable(){ })调用线程的方法来执行与第三方接口的交互 <bean id="syncTaskExecutor" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor"> <property name="corePoolSize" value="20" /> <property name="maxPoolSize" value="50" /> </bean> 来源： oschina 链接： https://my.oschina.net/u/2006835/blog/492265