前往小程序,Get更优阅读体验!
立即前往
首页
学习
活动
专区
工具
TVP
发布
社区首页 >专栏 >Android – ThreadPool介绍

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来管理线程池中的线程。

代码语言:javascript
复制
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:

代码语言:javascript
复制
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:

代码语言:javascript
复制
public class MainThreadExecutor implements Executor {

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

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

创建一个DefaultExecutorSupplier:

代码语言:javascript
复制
/*
* 单例的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;
    }
}

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

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

代码语言:javascript
复制
/*
* 执行后台任务
*/
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可以被用来取消任务。

代码语言:javascript
复制
/*
* 通过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:

代码语言:javascript
复制
/**
 * 优先级
 */
public enum Priority {

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

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

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

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

}

创建一个PriorityRunnable:

代码语言:javascript
复制
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>:

代码语言:javascript
复制
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:

代码语言:javascript
复制
public class DefaultExecutorSupplier{

private final PriorityThreadPoolExecutor mForBackgroundTasks;

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

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

代码语言:javascript
复制
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 删除

本文分享自 作者个人站点/博客 前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体同步曝光计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
0 条评论
热度
最新
推荐阅读
目录
  • ThreadPools
  • ThreadPoolExecutor
  • 为什么要在Android或者Java使用线程池?
  • 在Android中使用ThreadPoolExecutor
  • 该如何取消任务?
  • 如何设置任务的优先级?
领券
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档