Android – ThreadPool介绍

本篇内容为译文,翻译过来一起学习,一起进步 。

ThreadPool图解.png

下面将会介绍线程池、线程池使用方法以及在Android中如何使用。

ThreadPools

一个线程池管理一个工作线程池(具体的线程数量取决于它的实现方式)。 任务队列包含在线程池中任何一个空闲线程执行的任务。任务由生产者添加到队列中,工作线程充当消费者,只要有一个空闲线程准备好,就会消耗队列中的任务。

ThreadPoolExecutor

ThreadPoolExecutor来管理线程池中的线程。

ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
    int corePoolSize,
    int maximumPoolSize,
    long keepAliveTime,
    TimeUnit unit,
    BlockingQueue<Runnable> workQueue
);

参数介绍 ① corePoolSize:池中保留最小的线程数。最初池中是零个线程,但是随着任务被添加到队列中,新的线程被创建。如果有空闲线程,但是线程数是小于corePoolSize,那么新线程将会继续被创建。 ② maximumPoolSize:池中允许的最大线程数。如果超过了corePoolSize,并且当前线程数大于等于corePoolSize,那么只有当队列已满时,才会创建新的线程。 ③ keepAliveTime:当线程数大于核心线程数时,非核心线程(空闲线程)将等待新的任务。如果在这个时间内没有得到一个新的线程,那么它们将终止。 ④ unit:keepAliveTime的时间单位。 ⑤ workQueue:任务队列。它将只保存可运行的任务,这是一个BlockingQueue

为什么要在Android或者Java使用线程池?

① 这是一个强大的任务执行框架,它支持向队列中添加任务、取消任务、任务优先级。 ② 它减少了线程创建时的开销。因为它在线程池中管理所需的线程数量。

在Android中使用ThreadPoolExecutor

首先创建一个PriorityThreadFactory:

public class PriorityThreadFactory implements ThreadFactory {

    private final int mThreadPriority;

    public PriorityThreadFactory(int threadPriority) {
        mThreadPriority = threadPriority;
    }

    @Override
    public Thread newThread(final Runnable runnable) {
        Runnable wrapperRunnable = new Runnable() {
            @Override
            public void run() {
                try {
                    Process.setThreadPriority(mThreadPriority);
                } catch (Throwable t) {

                }
                runnable.run();
            }
        };
        return new Thread(wrapperRunnable);
    }
}

创建一个MainThreadExecutor:

public class MainThreadExecutor implements Executor {

    private final Handler handler = new Handler(Looper.getMainLooper());

    @Override
    public void execute(Runnable runnable) {
        handler.post(runnable);
    }
}

创建一个DefaultExecutorSupplier:

/*
* 单例的Executor
*/
public class DefaultExecutorSupplier{
    /*
    * 核心线程数量
    */
    public static final int NUMBER_OF_CORES = Runtime.getRuntime().availableProcessors();
    
    /*
    * 线程池执行后台任务
    */
    private final ThreadPoolExecutor mForBackgroundTasks;
    /*
    * 线程池执行轻微的后台任务
    */
    private final ThreadPoolExecutor mForLightWeightBackgroundTasks;
    /*
    * 线程池执行主线程任务
    */
    private final Executor mMainThreadExecutor;
    /*
    * DefaultExecutorSupplier的一个实例
    */
    private static DefaultExecutorSupplier sInstance;

    /*
    * 返回DefaultExecutorSupplier的实例
    */
    public static DefaultExecutorSupplier getInstance() {
       if (sInstance == null) {
         synchronized(DefaultExecutorSupplier.class){                                                                  
             sInstance = new DefaultExecutorSupplier();      
        }
        return sInstance;
    }

    /*
    * DefaultExecutorSupplier的构造函数
    */ 
    private DefaultExecutorSupplier() {
        
        // 设置 thread factory
        ThreadFactory backgroundPriorityThreadFactory = new 
                PriorityThreadFactory(Process.THREAD_PRIORITY_BACKGROUND);
        
        // 设置mForBackgroundTasks的线程池执行器;
        mForBackgroundTasks = new ThreadPoolExecutor(
                NUMBER_OF_CORES * 2,
                NUMBER_OF_CORES * 2,
                60L,
                TimeUnit.SECONDS,
                new LinkedBlockingQueue<Runnable>(),
                backgroundPriorityThreadFactory
        );
        
        // 为mForLightWeightBackgroundTasks设置线程池执行器;
        mForLightWeightBackgroundTasks = new ThreadPoolExecutor(
                NUMBER_OF_CORES * 2,
                NUMBER_OF_CORES * 2,
                60L,
                TimeUnit.SECONDS,
                new LinkedBlockingQueue<Runnable>(),
                backgroundPriorityThreadFactory
        );
        
        //设置mMainThreadExecutor的线程池执行器;
        mMainThreadExecutor = new MainThreadExecutor();
    }

    /*
    * 返回线程池中的后台任务
    */
    public ThreadPoolExecutor forBackgroundTasks() {
        return mForBackgroundTasks;
    }

    /*
    * 返回线程池中的轻微后台任务
    */
    public ThreadPoolExecutor forLightWeightBackgroundTasks() {
        return mForLightWeightBackgroundTasks;
    }

    /*
    * 返回线程池中主线程任务
    */
    public Executor forMainThreadTasks() {
        return mMainThreadExecutor;
    }
}

注意:线程池中的具体线程数量取决您的具体业务场景。

下面您可以在代码中使用它了:

/*
* 执行后台任务
*/
public void doSomeBackgroundWork(){
  DefaultExecutorSupplier.getInstance().forBackgroundTasks()
    .execute(new Runnable() {
    @Override
    public void run() {
       // some code...
    }
  });
}

/*
* 执行轻微的后台任务
*/
public void doSomeLightWeightBackgroundWork(){
  DefaultExecutorSupplier.getInstance().forLightWeightBackgroundTasks()
    .execute(new Runnable() {
    @Override
    public void run() {
       // some code...
    }
  });
}

/*
* 执行主线程任务
*/
public void doSomeMainThreadWork(){
  DefaultExecutorSupplier.getInstance().forMainThreadTasks()
    .execute(new Runnable() {
    @Override
    public void run() {
        // some code...
    }
  });
}

这样,咱们就可以为网络任务、IO任务、后台任务和其他任务创建一个不同的线程池。

该如何取消任务?

要取消任务,您必须得到这个任务的future。这里我们需要使用submit代替execute来返回一个future。这个future可以被用来取消任务。

/*
* 通过submit提交到线程池中来获取future
*/
Future future = DefaultExecutorSupplier.getInstance().forBackgroundTasks()
    .submit(new Runnable() {
    @Override
    public void run() {
      // do some background work here.
    }
});

/*
* 取消任务
*/
future.cancel(true); 

如何设置任务的优先级?

假设队列中有10个任务,线程池中只有4个线程。这时我们需要根据优先级来执行任务,因为池中只能执行4个任务。这时我们为队列中的最后一个线程设置IMMEDIATE优先级,当线程从队列中取任务时,就会先执行该任务(因为它的优先级高)。 要设置任务的优先级,需要先创建thread pool executor。 创建优先级的ENUM:

/**
 * 优先级
 */
public enum Priority {

    /**
     * 最低优先级。用于预取数据
     */
    LOW,

    /**
     * 中等优先级。用于预热可能很快可见的数据
     */
    MEDIUM,

    /**
     * 最高优先级。用于屏幕上当前可见的数据
     */
    HIGH,

    /**
     * 最高优先级。用于即时需要的数据(主要用于紧急情况)。
     */
    IMMEDIATE;

}

创建一个PriorityRunnable:

public class PriorityRunnable implements Runnable {

    private final Priority priority;

    public PriorityRunnable(Priority priority) {
        this.priority = priority;
    }

    @Override
    public void run() {
      // nothing to do here.
    }

    public Priority getPriority() {
        return priority;
    }

}

创建一个扩展ThreadPoolExecutor的PriorityThreadPoolExecutor。我们必须创建PriorityFutureTask,它将实现Comparable <PriorityFutureTask>:

public class PriorityThreadPoolExecutor extends ThreadPoolExecutor {

   public PriorityThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime,
         TimeUnit unit, ThreadFactory threadFactory) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit,new PriorityBlockingQueue<Runnable>(), threadFactory);
    }

    @Override
    public Future<?> submit(Runnable task) {
        PriorityFutureTask futureTask = new PriorityFutureTask((PriorityRunnable) task);
        execute(futureTask);
        return futureTask;
    }

    private static final class PriorityFutureTask extends FutureTask<PriorityRunnable>
            implements Comparable<PriorityFutureTask> {
        private final PriorityRunnable priorityRunnable;

        public PriorityFutureTask(PriorityRunnable priorityRunnable) {
            super(priorityRunnable, null);
            this.priorityRunnable = priorityRunnable;
        }
       
        @Override
        public int compareTo(PriorityFutureTask other) {
            Priority p1 = priorityRunnable.getPriority();
            Priority p2 = other.priorityRunnable.getPriority();
            return p2.ordinal() - p1.ordinal();
        }
    }
}

首先,在DefaultExecutorSupplier中,而不是ThreadPoolExecutor,像这样使用PriorityThreadPoolExecutor:

public class DefaultExecutorSupplier{

private final PriorityThreadPoolExecutor mForBackgroundTasks;

private DefaultExecutorSupplier() {
        mForBackgroundTasks = new PriorityThreadPoolExecutor(
                NUMBER_OF_CORES * 2,
                NUMBER_OF_CORES * 2,
                60L,
                TimeUnit.SECONDS,
                backgroundPriorityThreadFactory
        );
    }
}

下面是如何为任务添加高优先级示例:

public void doSomeTaskAtHighPriority(){
  DefaultExecutorSupplier.getInstance().forBackgroundTasks()
    .submit(new PriorityRunnable(Priority.HIGH) {
    @Override
    public void run() {
      // some code...
    }
});
}

通过上面方式,任务将会被考虑优先执行。

上面的实现方式也适用于JAVA应用程序

详细使用方式可以查看Android网络库

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏编程

浅析Windows下堆的结构

*本文原创作者:hellowuzekai,本文属FreeBuf原创奖励计划,未经许可禁止转载 简介 Windows下的堆主要有两种,进程的默认堆和自己创建的私有...

306100
来自专栏Java编程技术

创建线程以及线程池时候要指定与业务相关的名字,以便于追溯问题

日常开发中当一个应用中需要创建多个线程或者线程池时候最好给每个线程或者线程池根据业务类型设置具体的名字,以便在出现问题时候方便进行定位,下面就通过实例来说明不设...

10510
来自专栏Java 源码分析

Exectors框架 源码分析

Exectors框架 源码分析 1. 在阅读源码时做了大量的注释,并且做了一些测试分析源码内的执行流程,由于博客篇幅有限,并且代码阅读起来没有 IDE 方便,...

29270
来自专栏FreeBuf

浅析Windows下堆的结构

简介 Windows下的堆主要有两种,进程的默认堆和自己创建的私有堆。在程序启动时,系统在刚刚创建的进程虚拟地址空间中创建一个进程的默认堆,而且程序也可以通过 ...

25180
来自专栏Android机动车

线程池之小结

多线程:解决多任务同时执行的需求,合理使用CPU资源。多线程的运行是根据CPU切换完成,如何切换由CPU决定,因此多线程运行具有不确定性。

8530
来自专栏java达人

多线程设计模式解读4—Producer-Consumer模式

Producer-Consumer模式可以说是多线程设计模式之王,后期我们要讲的许多模式像Thread-Pool模式,Active Object模式等都是Pro...

13440
来自专栏向治洪

Android 四种常见的线程池

引入线程池的好处 1)提升性能。创建和消耗对象费时费CPU资源 2)防止内存过度消耗。控制活动线程的数量,防止并发线程过多。 我们来看一下线程池的简单的构造 ...

20470
来自专栏Java3y

线程池你真不来了解一下吗?

26660
来自专栏JMCui

多线程编程学习五(线程池的创建)

一、概述 New Thread的弊端如下:        a、每次New Thread新建对象性能差。        b、线程缺乏统一的管理,可能无限制的新建...

422110
来自专栏Java 源码分析

Exectors框架 源码分析

Exectors框架 源码分析 1. 在阅读源码时做了大量的注释,并且做了一些测试分析源码内的执行流程,由于博客篇幅有限,并且代码阅读起来没有 IDE 方便,...

27760

扫码关注云+社区

领取腾讯云代金券