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 条评论
登录 后参与评论

相关文章

来自专栏程序猿DD

基于Consul的分布式信号量实现

在之前《基于Consul的分布式锁实现》一文中我们介绍如何基于Consul的KV存储来实现分布式互斥锁。本文将继续讨论基于Consul的分布式锁实现。信号量是我...

2447
来自专栏刘望舒

Java高并发之线程池详解

在业务场景中, 如果一个对象创建销毁开销比较大, 那么此时建议池化对象进行管理。例如线程, jdbc连接等等, 在高并发场景中, 如果可以复用之前销毁的对象, ...

985
来自专栏栗霖积跬步之旅

1.10线程的优先级

在操作系统中,线程是有优先级划分的,优先级较高的线程会得到相对较多的资源。 也就是说CPU会优先执行优先级较高的线程对象中的任务。 设置线程优先级有助于帮“线程...

1635
来自专栏C++

Windows核心编程:第7章 线程调度、优先级和关联性

743
来自专栏服务端技术杂谈

获取线程池中任务执行数量

通过ThreadPoolExecutor的相关API实时获取线程数量,排队任务数量,执行完成线程数量等信息。

532
来自专栏程序员互动联盟

【面试宝典】Java 如何进行线程同步?

面试官:知道线程的同步吗? 小白:知道,线程的同步就是保证多个线程的共同资源在同一时刻只有一个线程在使用和修改,保证数据的唯一和准确。 面试官:那么如何保证数据...

3317
来自专栏java初学

java — 线程池

32111
来自专栏我是攻城师

关于自旋锁的公平和非公平模式

自旋锁是并发编程实战里面一个关于锁优化的非常重要的一个概念,通常情况下会配合CAS原语来实现轻量级的同步操作。

682
来自专栏Linyb极客之路

并发编程之ReentrantLock

一、简述 ReentrantLock 是一个可重入的互斥(/独占)锁,又称为“独占锁”。 ReentrantLock通过自定义队列同步器(AQS-Abstr...

3497
来自专栏xdecode

Java高并发之线程池详解

例如线程, jdbc连接等等, 在高并发场景中, 如果可以复用之前销毁的对象, 那么系统效率将大大提升.

812

扫码关注云+社区