android 基础之线程池

alp
136 阅读6分钟

几种常见的线程池

1：ThreadPoolExecutor 创建基本线程池

创建线程池，主要是利用ThreadPoolExecutor这个类，而这个类有几种构造方法，其中参数最多的一种构造方法如下：

  public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory) {
        ...
    }

corePoolSize: 该线程池中核心线程的数量。

注意：线程池中存在核心线程与非核心线程，核心线程一旦创建会一直执行任务或等待任务到来，而非核心线程只在任务队列塞满任务时去执行多出的任务，并且非核心线程在等待一段时间后将会被回收，这个时间作为参数可调配，见下面的keepAliveTime参数。

maximumPoolSize：该线程池中最大线程数量。(区别于corePoolSize)

keepAliveTime:从字面上就可以理解，是非核心线程空闲时要等待下一个任务到来的时间，当任务很多，每个任务执行时间很短的情况下调大该值有助于提高线程利用率。注意：当allowCoreThreadTimeOut属性设为true时，该属性也可用于核心线程。

unit:上面时间属性的单位

workQueue:任务队列，后面详述。

threadFactory:线程工厂，可用于设置线程名字等等，一般无须设置该参数。

设置好几个参数就可以创建一个基本的线程池，而之后的各种线程池都是在这种基本线程池的基础上延伸的。

下面贴个自己写的demo来熟悉具体的使用并且加深影响：

//创建基本线程池
final ThreadPoolExecutor threadPoolExecutor = 
new ThreadPoolExecutor(3,5,1L,TimeUnit.SECONDS,new LinkedBlockingQueue<Runnable>(100));

设置一个按钮mThreadPoolExecute，并在点击事件中使用线程池

 /**
  * 基本线程池使用
  */
 mThreadPoolExecute.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {

                for(int i = 0;i<30;i++){
                    final int finali = i;
                    Runnable runnable = new Runnable() {
                        @Override
                        public void run() {
                            try {
                                Thread.sleep(2000);
                                Log.d("Thread", "run: "+finali);
                                Log.d("当前线程：",Thread.currentThread().getName());
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                    };
                    threadPoolExecutor.execute(runnable);
                }
            }
        });

结果会每2s打印三个日志。

具体过程：

1.execute一个线程之后，如果线程池中的线程数未达到核心线程数，则会立马启用一个核心线程去执行。

2.execute一个线程之后，如果线程池中的线程数已经达到核心线程数，且workQueue未满，则将新任务放入workQueue中等待执行。

3.execute一个线程之后，如果线程池中的线程数已经达到核心线程数但未超过非核心线程数，且workQueue已满，则开启一个非核心线程来执行任务。

4.execute一个线程之后，如果线程池中的线程数已经超过非核心线程数，则拒绝执行该任务，采取饱和策略，并抛出RejectedExecutionException异常。

demo中设置的任务队列长度为100，所以不会开启额外的5-3=2个非核心线程，如果将任务队列设为25，则前三个任务被核心线程执行，剩下的30-3=27个任务进入队列会满，此时会开启2个非核心线程来执行剩下的两个任务。

//新开启了thread-4与thread-5执行剩下的超出队列的两个任务28和29
2019-03-28 15:54:07.879 22284-22618/com.example.threadpooltest D/Thread:: 1
2019-03-28 15:54:07.879 22284-22617/com.example.threadpooltest D/Thread:: 0
2019-03-28 15:54:07.879 22284-22617/com.example.threadpooltest D/当前线程：: pool-1-thread-1
2019-03-28 15:54:07.879 22284-22618/com.example.threadpooltest D/当前线程：: pool-1-thread-2
2019-03-28 15:54:07.880 22284-22619/com.example.threadpooltest D/Thread:: 2
2019-03-28 15:54:07.880 22284-22619/com.example.threadpooltest D/当前线程：: pool-1-thread-3
2019-03-28 15:54:07.881 22284-22620/com.example.threadpooltest D/Thread:: 28
2019-03-28 15:54:07.881 22284-22620/com.example.threadpooltest D/当前线程：: pool-1-thread-4
2019-03-28 15:54:07.881 22284-22621/com.example.threadpooltest D/Thread:: 29
2019-03-28 15:54:07.881 22284-22621/com.example.threadpooltest D/当前线程：: pool-1-thread-5

疑问：每个for循环里都有一个sleep（2000），为何会每隔2s打印三个任务？
原因：因为一开始的时候只是声明runnable对象并且重写run()方法，并没有运行，而后execute(runnable) 才会sleep，又因为一开始创建线程池的时候声明的核心线程数为3，所以会首先开启三个核心线程，然后执行各自的run方法，虽然有先后顺序，但这之间的间隔很短，所以2s后同时打印3个任务。

2：FixedThreadPool (可重用固定线程数)

Executors类中的创建方法：

//创建固定线程池
final ThreadPoolExecutor threadPoolExecutor = 
new ThreadPoolExecutor(3,3,0L,TimeUnit.SECONDS,new LinkedBlockingQueue<Runnable>());

FixedThreadPool创建

特点：只有核心线程，无非核心线程，并且阻塞队列无界。

从其特点可以看出，FixedThreadPool 适用于有大量不需要立即执行的耗时少的任务的情况

3：CachedThreadPool (按需创建)

Executors类中的创建方法：

//创建缓存线程池
final ThreadPoolExecutor threadPoolExecutor = 
new ThreadPoolExecutor(0,Integer.MAX_VALUE,60L,TimeUnit.SECONDS,new SynchronousQueue<Runnable>());

CachedThreadPool创建

特点：没有核心线程，只有非核心线程，并且每个非核心线程空闲等待的时间为60s，采用SynchronousQueue队列。

  • 因为没有核心线程，其他全为非核心线程，SynchronousQueue是不存储元素的

  • 当一个任务执行时，先用SynchronousQueue的offer提交任务，如果线程池中有线程空闲，则调用SynchronousQueue的poll方法来移除任务并交给线程处理；如果没有线程空闲，则开启一个新的非核心线程来处理任务。

  • 由于maximumPoolSize是无界的，所以如果线程处理任务速度小于提交任务的速度，则会不断地创建新的线程，这时需要注意不要过度创建，应采取措施调整双方速度，不然线程创建太多会影响性能。

  • 从其特点可以看出，CachedThreadPool适用于有大量需要立即执行的耗时少的任务的情况

4：SingleThreadPool(单个核线的fixed)

创建方法：

SingleThreadPool创建

new ThreadPoolExecutor(1, 1,0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>())

创建：

 //创建Single线程池
 final ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();

使用：

  /**
    * single线程池
    */
        mSinglePoolExecute.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                for(int i = 0;i<30;i++){
                    final int finali = i;x
                    Runnable runnable = new Runnable() {
                        @Override
                        public void run() {
                            try {
                                Thread.sleep(2000);
                                Log.d("Thread", "run: "+finali);
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                    };
                    singleThreadExecutor.execute(runnable);

                }
            }
        });

结果：每2s打印一个任务，由于只有一个核心线程，当被占用时，其他的任务需要进入队列等待。

适用：一个任务一个任务执行的场景

5：ScheduledThreadPool(定时延时执行)

创建方法：

public ScheduledThreadPoolExecutor(int corePoolSize) {    
    super(corePoolSize, Integer.MAX_VALUE, 10L, MILLISECONDS,
        new DelayedWorkQueue());
}

创建：

//创建Scheduled线程池
  final ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3);

使用：

  /**
    * scheduled线程池
    */
        mScheduledTheadPool.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {

                    Runnable runnable = new Runnable() {
                        @Override
                        public void run() {

                            Log.d("Thread", "This task is delayed to execute");
                    }

                    };
                    scheduledThreadPool.schedule(runnable,10,TimeUnit.SECONDS);//延迟启动任务

//延迟5s后启动，每1s执行一次             scheduledThreadPool.scheduleAtFixedRate(runnable,5,1,TimeUnit.SECONDS);
//启动后第一次延迟5s执行，后面延迟1s执行  scheduledThreadPool.scheduleWithFixedDelay(runnable,5,1,TimeUnit.SECONDS);
            }
        });

结果如代码所述。

6：自定义的PriorityThreadPool(队列中有优先级比较的线程池)

创建：

 //创建自定义线程池(优先级线程)
final ExecutorService priorityThreadPool = new ThreadPoolExecutor(3,3,0, TimeUnit.SECONDS,new PriorityBlockingQueue<Runnable>());

自定义Runnable，继承Comparable接口：

public abstract class PriorityRunnable implements Runnable,Comparable<PriorityRunnable> {
    private int priority;

    public  PriorityRunnable(int priority){
        if(priority <0) {
            throw new IllegalArgumentException();
        }
        this.priority = priority;
    }

    public int getPriority() {
        return priority;
    }

    @Override
    public int compareTo(@NonNull PriorityRunnable another) {
        int me = this.priority;
        int anotherPri=another.getPriority();
        return me == anotherPri ? 0 : me < anotherPri ? 1 : -1;
    }

    @Override
    public void run() {
            doSomeThing();
    }

    protected abstract void doSomeThing();
}

利用抽象类继承Comparable接口重写其中的compareTo方法来比较优先级。

使用：

  mMyPriorityTheadPool.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                for(int i = 0;i<30;i++){
                    final int priority = i;
                    priorityThreadPool.execute(new PriorityRunnable(priority) {
                        @Override
                        protected void doSomeThing() {
                            Log.d("MainActivity", "优先级为 "+priority+"  的任务被执行");
                            try {
                                Thread.sleep(2000);
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                    });

                }
            }
        });

结果：前三个任务被创建的三个核心线程执行，之后的27个任务进入队列并且调用compareTo方法进行排序，之后打印出来的是经过排序后从大到小的顺序。

三：JAVA中的阻塞队列

由于上面的构造方法涉及到了阻塞队列，所以补充一些阻塞队列的知识。
阻塞队列：我的理解是，生产者——消费者，生产者往队列里放元素，消费者取，如果队列里没有元素，消费者线程取则阻塞，如果队列里元素满了，则生产者线程阻塞。

常见的阻塞队列有下列7种：

ArrayBlockingQueue ：一个由数组结构组成的有界阻塞队列。
LinkedBlockingQueue ：一个由链表结构组成的有界阻塞队列。
PriorityBlockingQueue ：一个支持优先级排序的无界阻塞队列。
DelayQueue：一个使用优先级队列实现的无界阻塞队列。
SynchronousQueue：一个不存储元素的阻塞队列。
LinkedTransferQueue：一个由链表结构组成的无界阻塞队列。
LinkedBlockingDeque：一个由链表结构组成的双向阻塞队列。

具体情况具体分析，选择合适的队列。
由于只是补充部分，所以具体使用及实现原理请百度。

四：各个线程池总结及适用场景

newCachedThreadPool：

底层：返回ThreadPoolExecutor实例，corePoolSize为0；maximumPoolSize为Integer.MAX_VALUE；keepAliveTime为60L；unit为TimeUnit.SECONDS；workQueue为SynchronousQueue(同步队列)
通俗：当有新任务到来，则插入到SynchronousQueue中，由于SynchronousQueue是同步队列，因此会在池中寻找可用线程来执行，若有可以线程则执行，若没有可用线程则创建一个线程来执行该任务；若池中线程空闲时间超过指定大小，则该线程会被销毁。
适用：执行很多短期异步的小程序或者负载较轻的服务器

newFixedThreadPool：

底层：返回ThreadPoolExecutor实例，接收参数为所设定线程数量nThread，corePoolSize为nThread，maximumPoolSize为nThread；keepAliveTime为0L(不限时)；unit为：TimeUnit.MILLISECONDS；WorkQueue为：new LinkedBlockingQueue() 无解阻塞队列
通俗：创建可容纳固定数量线程的池子，每隔线程的存活时间是无限的，当池子满了就不再添加线程了；如果池中的所有线程均在繁忙状态，对于新任务会进入阻塞队列中(无界的阻塞队列)
适用：执行长期的任务，性能好很多

newSingleThreadExecutor:

底层：FinalizableDelegatedExecutorService包装的ThreadPoolExecutor实例，corePoolSize为1；maximumPoolSize为1；keepAliveTime为0L；unit为：TimeUnit.MILLISECONDS；workQueue为：new LinkedBlockingQueue() 无解阻塞队列
通俗：创建只有一个线程的线程池，且线程的存活时间是无限的；当该线程正繁忙时，对于新任务会进入阻塞队列中(无界的阻塞队列)
适用：一个任务一个任务执行的场景

newScheduledThreadPool:

底层：创建ScheduledThreadPoolExecutor实例，

corePoolSize为传递来的参数，

maximumPoolSize为Integer.MAX_VALUE；

keepAliveTime为10；

unit为：TimeUnit.MILLISECONDS；

workQueue为：new DelayedWorkQueue() 一个按超时时间升序排序的队列

通俗：创建一个无限大小的线程池，线程池内非核心线程存活时间10mill，线程池可以支持定时及周期性任务执行，对于新任务会进入DelayedWorkQueue队列中，这是一种按照超时时间排序的队列结构

适用：周期性或定时执行任务的场景

五：线程池其它方法：

1.shutDown()  关闭线程池，不影响已经提交的任务

2.shutDownNow() 关闭线程池，并尝试去终止正在执行的线程

3.allowCoreThreadTimeOut(boolean value) 允许核心线程闲置超时时被回收

4.submit 一般情况下我们使用execute来提交任务，但是有时候可能也会用到submit，使用submit的好处是submit有返回值。

5.beforeExecute() - 任务执行前执行的方法

6.afterExecute() -任务执行结束后执行的方法

7.terminated() -线程池关闭后执行的方法

参照：www.jianshu.com/p/7b2da1d94…

线程池的RejectedExecutionHandler（拒绝策略）

pool.setRejectedExcutionHandler()

在使用线程池并且使用有界队列的时候，如果队列满了，任务添加到线程池的时候就会有问题，针对这些问题java线程池提供了以下几种策略：

  • AbortPolicy

  • DiscardPolicy

  • DiscardOldestPolicy

  • **CallerRunsPolicy
    **

  • 自定义

◇AbortPolicy

该策略是线程池的默认策略。使用该策略时，如果线程池队列满了丢掉这个任务并且抛出RejectedExecutionException异常。

源码如下：

 public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {            //不做任何处理，直接抛出异常            throw new RejectedExecutionException("Task " + r.toString() +                                                 " rejected from " +                                                 e.toString());        }

◇DiscardPolicy

这个策略和AbortPolicy的slient版本，如果线程池队列满了，会直接丢掉这个任务并且不会有任何异常。

源码如下：

   public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {        	//就是一个空的方法        }

◇DiscardOldestPolicy

这个策略从字面上也很好理解，丢弃最老的。也就是说如果队列满了，会将最早进入队列的任务删掉腾出空间，再尝试加入队列。

因为队列是队尾进，队头出，所以队头元素是最老的，因此每次都是移除对头元素后再尝试入队。

源码如下：

        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {            if (!e.isShutdown()) {            	//移除队头元素                e.getQueue().poll();                //再尝试入队                e.execute(r);            }        }

CallerRunsPolicy

使用此策略，如果添加到线程池失败，那么主线程会自己去执行该任务，不会等待线程池中的线程去执行。就像是个急脾气的人，我等不到别人来做这件事就干脆自己干。

源码如下：

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {            if (!e.isShutdown()) {                //直接执行run方法                r.run();            }        }

自定义

如果以上策略都不符合业务场景，那么可以自己定义一个拒绝策略，只要实现RejectedExecutionHandler接口，并且实现rejectedExecution方法就可以了。具体的逻辑就在rejectedExecution方法里去定义就OK了。

例如：我定义了我的一个拒绝策略，叫做MyRejectPolicy，里面的逻辑就是打印处理被拒绝的任务内容

public class MyRejectPolicy implements RejectedExecutionHandler{    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {        //Sender是我的Runnable类，里面有message字段        if (r instanceof Sender) {            Sender sender = (Sender) r;            //直接打印            System.out.println(sender.getMessage());        }    }}

这几种策略没有好坏之分，只是适用不同场景，具体哪种合适根据具体场景和业务需要选择，如果需要特殊处理就自己定义好了。

avatar
文章
阅读
粉丝