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 開發》