Android 在线程池中实现线程优先级的代码实现

Android 在线程池中实现线程优先级的代码实现

---

在前文《Android 中设置线程优先级的正确方式（2种方法）》中，我们知道，设置线程优先级，最好使用 Android 推荐的 android.os.Process 类的 setThreadPriority 方法。该方法需要在需要在线程执行时调用，也就是需要在 run 方法里面调用。

单个线程执行时，非常简单，那如果我们需要在线程池里设置现场优先级，又如何操作呢？

这里我直接给出了一个模板示例，按照自己的需要修改参数即可：

package com.budaye.simpledemo;

import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.os.Process;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 异步线程池
 *
 * @author bu
 */
public class AsyncThreadTask {
    private final int CPU_COUNT = Runtime.getRuntime().availableProcessors(); //cup内核数
    private final int DEAFULT_THREAD_COUNT = CPU_COUNT + 3; //默认核心线程数
    private final int KEEP_ALIVE = 3; //空线程alive时间
    private ExecutorService mThreadPool; //线程池
    private ThreadFactory mBackgroundThreadFactory = new PriorityThreadFactory(Process.THREAD_PRIORITY_BACKGROUND);
    private InternalHandler mHandler;
    private static AsyncThreadTask instance;

    public static AsyncThreadTask getInstance() {
        if (instance == null) {
            synchronized (AsyncThreadTask.class) {
                if (instance == null) {
                    instance = new AsyncThreadTask();
                }
            }
        }
        return instance;
    }

    /**
     * 构造函数
     */
    private AsyncThreadTask() {
        // 创建线程池
        mThreadPool = new ThreadPoolExecutor(DEAFULT_THREAD_COUNT, DEAFULT_THREAD_COUNT, KEEP_ALIVE,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<Runnable>(10000),
                mBackgroundThreadFactory, new ThreadPoolExecutor.DiscardOldestPolicy());

    }

    /**
     * 异步线程执行任务
     *
     * @param runnable
     */
    public static void execute(Runnable runnable) {
        AsyncThreadTask.getInstance().executeRunnable(runnable);
    }

    /**
     * 异步线程执行延迟任务
     *
     * @param runnable
     * @param delayedTime
     */
    public static void executeDelayed(Runnable runnable, long delayedTime) {
        AsyncThreadTask.getInstance().executeRunnableDelayed(runnable, delayedTime);
    }

    public static void executeDelayedToUI(Runnable runnable, long delayedTime) {
        AsyncThreadTask.getInstance().executeRunnableDelayedToUI(runnable, delayedTime);
    }

    private void executeRunnableDelayedToUI(final Runnable runnable, long delayedTime) {
        getHandler().postDelayed(runnable, delayedTime);
    }

    private void executeRunnable(Runnable runnable) {
        mThreadPool.execute(runnable);
    }

    private void executeRunnableDelayed(final Runnable runnable, long delayedTime) {
        getHandler().postDelayed(new Runnable() {
            @Override
            public void run() {
                mThreadPool.execute(runnable);
            }
        }, delayedTime);
    }


    private Handler getHandler() {
        synchronized (this) {
            if (mHandler == null) {
                mHandler = new InternalHandler();
            }
            return mHandler;
        }
    }

    private static class InternalHandler extends Handler {
        public InternalHandler() {
            super(Looper.getMainLooper());
        }

        @Override
        public void handleMessage(Message msg) {

        }
    }

    public class PriorityThreadFactory implements ThreadFactory {
        private final AtomicInteger mCount = new AtomicInteger(1);
        private final int mThreadPriority;

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

        @Override
        public Thread newThread(final Runnable runnable) {
            Runnable riorityRunnable = new Runnable() {
                @Override
                public void run() {
                    Process.setThreadPriority(mThreadPriority);
                    runnable.run();
                }
            };
            return new Thread(riorityRunnable, "AsyncThreadTask #" + mCount.getAndIncrement());
        }
    }
}

---

**PS：更多精彩内容，请查看 --> 《Android 开发》
**PS：更多精彩内容，请查看 --> 《Android 开发》
**PS：更多精彩内容，请查看 --> 《Android 开发》