Java线程池相关知识点总结

时间  2019-12-16
标签 java 线程 相关 知识 总结 栏目 Java 繁體版
原文   原文链接

Android中常见到的不少通用组件通常都离不开”池”的概念，如各类图片加载库，网络请求库，即便Android的消息传递机制中的Meaasge当使用Meaasge.obtain()就是使用的Meaasge池中的对象，所以这个概念很重要。本文将介绍的线程池技术一样符合这一思想。java

  1. 线程池的优势:
    重用线程池中的线程,减小因对象建立,销毁所带来的性能开销;
    能有效的控制线程的最大并发数,提升系统资源利用率,同时避免过多的资源竞争,避免堵塞;
    可以多线程进行简单的管理,使线程的使用简单、高效。面试

  2. 线程池框架Executor
    java中的线程池是经过Executor框架实现的，Executor 框架包括类：Executor，Executors，ExecutorService，ThreadPoolExecutor ，Callable和Future、FutureTask的使用等。微信

Executor: 全部线程池的接口,只有一个方法。网络

public interface Executor {        
  void execute(Runnable command);      
}

ExecutorService: 增长Executor的行为，是Executor实现类的最直接接口。
Executors： 提供了一系列工厂方法用于创先线程池，返回的线程池都实现了ExecutorService 接口。
ThreadPoolExecutor：线程池的具体实现类,通常用的各类线程池都是基于这个类实现的。
构造方法以下:多线程

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) {
                              
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), defaultHandler);
}

参数介绍：
corePoolSize：线程池的核心线程数,线程池中运行的线程数也永远不会超过 corePoolSize 个,默认状况下能够一直存活。能够经过设置allowCoreThreadTimeOut为True,此时 核心线程数就是0,此时keepAliveTime控制全部线程的超时时间。
maximumPoolSize：线程池容许的最大线程数;
keepAliveTime： 指的是空闲线程结束的超时时间;
unit ：是一个枚举，表示 keepAliveTime 的单位;
workQueue：表示存听任务的BlockingQueue<Runnable队列。
BlockingQueue:阻塞队列（BlockingQueue）是java.util.concurrent下的主要用来控制线程同步的工具。若是BlockQueue是空的,从BlockingQueue取东西的操做将会被阻断进入等待状态,直到BlockingQueue进了东西才会被唤醒。一样,若是BlockingQueue是满的,任何试图往里存东西的操做也会被阻断进入等待状态,直到BlockingQueue里有空间才会被唤醒继续操做。
阻塞队列经常使用于生产者和消费者的场景，生产者是往队列里添加元素的线程，消费者是从队列里拿元素的线程。阻塞队列就是生产者存放元素的容器，而消费者也只从容器里拿元素。具体的实现类有LinkedBlockingQueue,ArrayBlockingQueued等。通常其内部的都是经过Lock和Condition(显示锁（Lock）及Condition的学习与使用)来实现阻塞和唤醒。并发

3.线程池的工做过程
线程池刚建立时，里面没有一个线程。任务队列是做为参数传进来的。不过，就算队列里面有任务，线程池也不会立刻执行它们。
当调用 execute() 方法添加一个任务时，线程池会作以下判断：
若是正在运行的线程数量小于 corePoolSize，那么立刻建立线程运行这个任务；
若是正在运行的线程数量大于或等于 corePoolSize，那么将这个任务放入队列；
若是这时候队列满了，并且正在运行的线程数量小于 maximumPoolSize，那么仍是要建立非核心线程马上运行这个任务；
若是队列满了，并且正在运行的线程数量大于或等于 maximumPoolSize，那么线程池会抛出异常RejectExecutionException。
当一个线程完成任务时，它会从队列中取下一个任务来执行。
当一个线程无事可作，超过必定的时间（keepAliveTime）时，线程池会判断，若是当前运行的线程数大于 corePoolSize，那么这个线程就被停掉。因此线程池的全部任务完成后，它最终会收缩到 corePoolSize 的大小。框架

4.线程池的建立和使用
生成线程池采用了工具类Executors的静态方法，如下是几种常见的线程池。
1）SingleThreadExecutor：单个后台线程 (其缓冲队列是无界的)工具

public static ExecutorService newSingleThreadExecutor() {        
    return new FinalizableDelegatedExecutorService (
        new ThreadPoolExecutor(1, 1,                                    
        0L, TimeUnit.MILLISECONDS,                                    
        new LinkedBlockingQueue<Runnable>()));   
}

建立一个单线程的线程池。这个线程池只有一个核心线程在工做，也就是至关于单线程串行执行全部任务。若是这个惟一的线程由于异常结束，那么会有一个新的线程来替代它。此线程池保证全部任务的执行顺序按照任务的提交顺序执行。性能

2）FixedThreadPool：只有核心线程的线程池,大小固定 (其缓冲队列是无界的) 。学习

public static ExecutorService newFixedThreadPool(int nThreads) {         
        return new ThreadPoolExecutor(nThreads, nThreads,                                       
            0L, TimeUnit.MILLISECONDS,                                         
            new LinkedBlockingQueue<Runnable>());     
}

建立固定大小的线程池。每次提交一个任务就建立一个线程，直到线程达到线程池的最大大小。线程池的大小一旦达到最大值就会保持不变，若是某个线程由于执行异常而结束，那么线程池会补充一个新线程。
3）CachedThreadPool：无界线程池，能够进行自动线程回收。

public static ExecutorService newCachedThreadPool() {         
    return new ThreadPoolExecutor(0,Integer.MAX_VALUE,                                           
           60L, TimeUnit.SECONDS,                                       
           new SynchronousQueue<Runnable>());     
}

若是线程池的大小超过了处理任务所须要的线程，那么就会回收部分空闲（60秒不执行任务）的线程，当任务数增长时，此线程池又能够智能的添加新线程来处理任务。此线程池不会对线程池大小作限制，线程池大小彻底依赖于操做系统（或者说JVM）可以建立的最大线程大小。SynchronousQueue是一个是缓冲区为1的阻塞队列。
4）ScheduledThreadPool：核心线程池固定，大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。

public static ExecutorService newScheduledThreadPool(int corePoolSize) {         
    return new ScheduledThreadPool(corePoolSize, 
              Integer.MAX_VALUE,                                                  
              DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,                                                    
              new DelayedWorkQueue());    
}

5.线程池实现的原理
若是只讲线程池的使用，那这篇博客没有什么大的价值，充其量也就是熟悉Executor相关API的过程。线程池的实现过程没有用到Synchronized关键字，用的都是volatile,Lock和同步(阻塞)队列,Atomic相关类，FutureTask等等，由于后者的性能更优。理解的过程能够很好的学习源码中并发控制的思想。

在ThreadPoolExecutor主要Worker类来控制线程的复用。看下Worker类简化后的代码，这样方便理解：

private final class Worker implements Runnable {
 
	final Thread thread;
    
	Runnable firstTask;
    
	Worker(Runnable firstTask) {
		this.firstTask = firstTask;
		this.thread = getThreadFactory().newThread(this);
	}
    
	public void run() {
		runWorker(this);
	}
	
	final void runWorker(Worker w) {
		Runnable task = w.firstTask;
		w.firstTask = null;
		while (task != null || (task = getTask()) != null){
		task.run();
	}
}

Worker是一个Runnable，同时拥有一个thread，这个thread就是要开启的线程，在新建Worker对象时同时新建一个Thread对象，同时将Worker本身做为参数传入TThread，这样当Thread的start()方法调用时，运行的其实是Worker的run()方法，接着到runWorker()中,有个while循环，一直从getTask()里获得Runnable对象，顺序执行。getTask()又是怎么获得Runnable对象的呢？

private Runnable getTask() {
    if(一些特殊状况) {
        return null;
    }

    Runnable r = workQueue.take();

    return r;
}

这个workQueue就是初始化ThreadPoolExecutor时存听任务的BlockingQueue队列，这个队列里的存放的都是将要执行的Runnable任务。由于BlockingQueue是个阻塞队列，BlockingQueue.take()获得若是是空，则进入等待状态直到BlockingQueue有新的对象被加入时唤醒阻塞的线程。因此通常状况Thread的run()方法就不会结束,而是不断执行从workQueue里的Runnable任务，这就达到了线程复用的原理了。

我是面试课的DocMike老师，曾在阿里、百度、美团，最近和北大同窗搞了一个
职场类公众号： 健男说说 ，会有热门互联网职场咨询和经验，能够关注下，
也能够加我私人微信 570089514，注明慕课网就能够
之后有相关面试、内推、简历、职场的问题均可以经过微信和公众号给我反馈
但愿本身这么多年走过的弯路 可以给你们一些帮助

控制最大并发数：
那Runnable是何时放入workQueue？Worker又是何时建立，Worker里的Thread的又是何时调用start()开启新线程来执行Worker的run()方法的呢？有上面的分析看出Worker里的runWorker()执行任务时是一个接一个，串行进行的，那并发是怎么体现的呢？
很容易想到是在execute(Runnable runnable)时会作上面的一些任务。看下execute里是怎么作的。

public void execute(Runnable command) {
    if (command == null)
        throw new NullPointerException();

     int c = ctl.get();
    // 当前线程数 < corePoolSize
    if (workerCountOf(c) < corePoolSize) {
        // 直接启动新的线程。
        if (addWorker(command, true))
            return;
        c = ctl.get();
    }

    // 活动线程数 >= corePoolSize
    // runState为RUNNING && 队列未满
    // workQueue.offer(command)表示添加到队列，若是添加成功返回true，不然返回false
    if (isRunning(c) && workQueue.offer(command)) {
        int recheck = ctl.get();
        // 再次检验是否为RUNNING状态
        // 非RUNNING状态 则从workQueue中移除任务并拒绝
        if (!isRunning(recheck) && remove(command))
            reject(command);// 采用线程池指定的策略拒绝任务
        // 两种状况：
        // 1.非RUNNING状态拒绝新的任务
        // 2.队列满了启动新的线程失败（workCount > maximumPoolSize）
    } else if (!addWorker(command, false))
        reject(command);
}

根据代码再来看上面提到的线程池工做过程当中的添加任务的状况：
若是正在运行的线程数量小于 corePoolSize，那么立刻建立线程运行这个任务；
若是正在运行的线程数量大于或等于 corePoolSize，那么将这个任务放入队列；
若是这时候队列满了，并且正在运行的线程数量小于 maximumPoolSize，那么仍是要建立非核心线程马上运行这个任务；
若是队列满了，并且正在运行的线程数量大于或等于 maximumPoolSize，那么线程池会抛出异常RejectExecutionException。

做者：DocMike连接：http://www.imooc.com/article/19226来源：慕课网

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程