线程池、Handler、HandlerThread 执行耗时任务的Demo

1. 线程池、Handler、HandlerThread 执行耗时任务的Demo

• Executors.newFixedThreadPool(8):
  定长线程池
• Executors.newSingleThreadScheduledExecutor():
  单线程的定时任务调度线程池,支持定时以及周期性执行任务
• Handler
  默认Loop为Main，故主要为其他线程与主线程通讯，例如某线程执行完耗时任务后，使用Handler汇报给主线程，让主线程需要刷新UI了
• HandlerThread
  Loop需要自行指定，谁指定谁就是老大即工作线程，例如某线程执行完耗时任务后，使用HandlerThread汇报给工作线程，让工作线程做事

2. 代码

2.1 线程工具类

package com.sufadi.study;

import android.os.Handler;
import android.os.HandlerThread;
import android.os.Looper;
import android.util.Log;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * 线程池调用Demo
 * Handle调用Demo
 * HandleThread调用Demo
 */
public class ThreadUtils {

    private static ThreadUtils instance;

    // 定长线程池
    private ExecutorService executorService;

    // 单线程的定时任务调度线程池,支持定时以及周期性执行任务
    private ScheduledExecutorService scheduledExecutorService;

    // 主线程Handler：便于和主线程进行通信，用于前台UI刷新用途
    private Handler mainHandler;

    // 工作线程：用于后台耗时任务
    private Handler bgHandler;
    private HandlerThread bgThread;

    public static ThreadUtils getInstance() {
        if (instance == null) {
            instance = new ThreadUtils();
        }
        return instance;
    }


    public ThreadUtils() {
        // 创建一个定长线程池
        executorService = Executors.newFixedThreadPool(8);
        scheduledExecutorService = Executors.newSingleThreadScheduledExecutor();
        mainHandler = new Handler(Looper.getMainLooper());

        bgThread = new HandlerThread("Bg thread");
        bgThread.start();
        bgHandler = new Handler(bgThread.getLooper());
    }

    /**
     * 定长线程池
     */
    void runOnBgThreadUseExecutor(Runnable task) {
        executorService.execute(task);
    }

    /**
     * 单线程的定时任务调度线程池
     */
    void runOnBgThreadDelayUseExecutor(Runnable task, int delayTime) {
        Log.d("Shz_tag", "call runOnBgThreadDelayUseExecutor");
        scheduledExecutorService.schedule(task, delayTime, TimeUnit.MILLISECONDS);
    }

    /**
     * 刷新UI
     */
    void runOnUiThread(Runnable task) {
        mainHandler.post(task);
    }


    /**
     * 延时刷新UI
     */
    void runOnUiThreadDelay(Runnable task, long time) {
        Log.d("Shz_tag", "call runOnUiThreadDelay");
        mainHandler.postDelayed(task, time);
    }

    /**
     * 工作线程：用于执行后台耗时任务
     */
    void runOnBgThread(Runnable task) {
        bgHandler.post(task);
    }

    /**
     * 工作线程：用于延时执行后台耗时任务
     */
    void runOnBgThreadDelay(Runnable task, long time) {
        Log.d("Shz_tag", "call runOnBgThreadDelay");
        bgHandler.postDelayed(task, time);
    }
}

2.2 调用线程工具类

package com.sufadi.study

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.util.Log
import java.io.File

class MainActivity : AppCompatActivity() {

    companion object {
        val TAG = "Shz_tag"
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        Log.d(TAG, "本demo用途：主要是提供Handler、HandlerThread、Executor 的API使用例子\n" +
                "1. Handler：默认Loop为Main，故主要为其他线程与主线程通讯，例如某线程执行完耗时任务后，使用Handler汇报给主线程，让主线程需要刷新UI了\n" +
                "2. HandlerThread:Loop需要自行指定，谁指定谁就是老大即工作线程，例如某线程执行完耗时任务后，使用HandlerThread汇报给工作线程，让工作线程做事\n" +
                "3. Executor：线程池，主要进行后台耗时任务。例如执行复制大文件等耗时任务。\n")

        ThreadUtils.getInstance().runOnBgThreadDelayUseExecutor({
            Log.d(TAG, "runOnBgThreadDelayUseExecutor: 执行线程池")
        }, 1000)

        ThreadUtils.getInstance().runOnBgThreadUseExecutor {
            Log.d(TAG, "runOnBgThreadUseExecutor: 延时执行线程池")
        }

        ThreadUtils.getInstance().runOnUiThread {
            Log.d(TAG, "runOnUiThread: 刷新UI")
        }

        ThreadUtils.getInstance().runOnUiThreadDelay({ Log.d(TAG, "runOnUiThreadDelay: 延时刷新UI") }, 1000)

        ThreadUtils.getInstance().runOnBgThread {
            Log.d(TAG, "runOnBgThread: 执行后台耗时任务")
        }

        ThreadUtils.getInstance().runOnBgThreadDelay({ Log.d(TAG, "runOnBgThreadDelay: 延时执行后台耗时任务") }, 1000)
    }


}

2.3 运行结果

2022-02-06 13:03:21.222 5971-5971/com.sufadi.study D/Shz_tag: 本demo用途：主要是提供Handler、HandlerThread、Executor 的API使用例子
    1. Handler：默认Loop为Main，故主要为其他线程与主线程通讯，例如某线程执行完耗时任务后，使用Handler汇报给主线程，让主线程需要刷新UI了
    2. HandlerThread:Loop需要自行指定，谁指定谁就是老大即工作线程，例如某线程执行完耗时任务后，使用HandlerThread汇报给工作线程，让工作线程做事
    3. Executor：线程池，主要进行后台耗时任务。例如执行复制大文件等耗时任务。
2022-02-06 13:03:21.223 5971-5971/com.sufadi.study D/Shz_tag: call runOnBgThreadDelayUseExecutor
2022-02-06 13:03:21.225 5971-5971/com.sufadi.study D/Shz_tag: call runOnUiThreadDelay
2022-02-06 13:03:21.225 5971-6011/com.sufadi.study D/Shz_tag: runOnBgThreadUseExecutor: 延时执行线程池
2022-02-06 13:03:21.225 5971-5971/com.sufadi.study D/Shz_tag: call runOnBgThreadDelay
2022-02-06 13:03:21.225 5971-6009/com.sufadi.study D/Shz_tag: runOnBgThread: 执行后台耗时任务
2022-02-06 13:03:21.258 5971-5971/com.sufadi.study D/Shz_tag: runOnUiThread: 刷新UI
2022-02-06 13:03:22.224 5971-6010/com.sufadi.study D/Shz_tag: runOnBgThreadDelayUseExecutor: 执行线程池
2022-02-06 13:03:22.225 5971-5971/com.sufadi.study D/Shz_tag: runOnUiThreadDelay: 延时刷新UI
2022-02-06 13:03:22.226 5971-6009/com.sufadi.study D/Shz_tag: runOnBgThreadDelay: 延时执行后台耗时任务