Android – ThreadPool介绍

code_horse

发布于 2018-07-02 14:08:36

4700

发布于 2018-07-02 14:08:36

文章被收录于专栏：Android Note

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

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网络库

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2017.11.12 ，如有侵权请联系 cloudcommunity@tencent.com 删除

android