Android开发之可以在任意页面开启主线程和使用线程池开启子线程的工具类

代码很简单说下思路，只需要使用handler通信即可，点击跳转源码页面链接🔗

package cn.xiayiye5.xiayiye5library.thread;

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

import androidx.annotation.NonNull;

import cn.xiayiye5.xiayiye5library.inter.MainThreadCallBack;

/**
 * @author : xiayiye5
 * @date : 2021/1/18 10:42
 * 类描述 : 在任意页面进行主线程开启
 */
public class MainThread {
    private MainThreadCallBack mainThreadCallBack;
    private static final MainThread MAIN_THREAD = new MainThread();

    private MainThread() {
    }

    public static MainThread getInstance() {
        return MAIN_THREAD;
    }

    private final Handler handler = new Handler(Looper.getMainLooper()) {
        @Override
        public void handleMessage(@NonNull Message msg) {
            super.handleMessage(msg);
            //回调主线程
            mainThreadCallBack.onFinish();
        }
    };

    /**
     * 此方法可以在activity fragment 任意页面进行主线程开启
     *
     * @param mainThreadCallBack 回调
     */
    public void open(MainThreadCallBack mainThreadCallBack) {
        this.mainThreadCallBack = mainThreadCallBack;
        //发送消息，回调到主线程
        handler.sendEmptyMessage(0);
    }
}

看下开启主线程的方法：

MainThread.getInstance().open(new MainThreadCallBack() {
            @Override
            public void onFinish() {
                
            }
        });

在看下使用线程池开启子线程的方法，可点击查看源码链接🔗

package cn.xiayiye5.xiayiye5library.utils;


import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @author : xiayiye5
 * @date : 2021/1/18 10:12
 * 类描述 : 线程池相关,不建议使用java包装好的线程池工具类Executors
 */
public class ThreadUtils {
    /**
     * 线程池相关参数,请点击查看{@link android.os.AsyncTask}
     */
    private static final int CORE_POOL_SIZE = Runtime.getRuntime().availableProcessors();
    private static final int MAXI_MUM_POOL_SIZE = CORE_POOL_SIZE * 2 + 1;
    private static final long KEEP_ALIVE_TIME = 10;
    private static final TimeUnit UNIT = TimeUnit.HOURS;
    private static final BlockingQueue<Runnable> WORK_QUEUE = new LinkedBlockingDeque<>(10);
    private static final ThreadFactory THREAD_FACTORY = Executors.defaultThreadFactory();
    private static final RejectedExecutionHandler HANDLER = new ThreadPoolExecutor.AbortPolicy();
    private static final ThreadPoolExecutor THREAD_POOL_EXECUTOR = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXI_MUM_POOL_SIZE, KEEP_ALIVE_TIME, UNIT, WORK_QUEUE, THREAD_FACTORY, HANDLER);

    private ThreadUtils() {
    }

    private static final ThreadUtils THREAD_UTILS = new ThreadUtils();

    public static ThreadUtils getInstance() {
        return THREAD_UTILS;
    }

    /**
     * 创建线程池
     *
     * @param runnable runnable接口
     */
    public void createThread(Runnable runnable) {
        THREAD_POOL_EXECUTOR.execute(runnable);
    }

    /**
     * 移除线程池
     *
     * @param runnable runnable接口
     */
    public void removeThread(Runnable runnable) {
        THREAD_POOL_EXECUTOR.remove(runnable);
    }
}