添加简易版本线程池封装

yangchong211 · Jun 4, 2022 · ebe5cc9 · ebe5cc9
1 parent 94ddb11
commit ebe5cc9
Show file tree

Hide file tree

Showing 78 changed files with 1,299 additions and 497 deletions.
diff --git a/.gitignore b/.gitignore
@@ -53,3 +53,5 @@ google-services.json
 freeline.py
 freeline/
 freeline_project_description.json
+.idea/
+.gradle/
diff --git a/.idea/modules.xml b/.idea/modules.xml
diff --git a/EasyExecutor/src/main/java/com/yc/easyexecutor/AbsTaskExecutor.java b/EasyExecutor/src/main/java/com/yc/easyexecutor/AbsTaskExecutor.java
@@ -1,5 +1,7 @@
 package com.yc.easyexecutor;
 
+import android.os.Handler;
+
 import androidx.annotation.NonNull;
 import androidx.annotation.RestrictTo;
 
@@ -13,15 +15,55 @@
  *     GitHub : https://github.com/yangchong211/YCThreadPool
  * </pre>
  */
-@RestrictTo(RestrictTo.Scope.LIBRARY)
 public abstract class AbsTaskExecutor {
 
+    /**
+     * 核心任务的线程池，执行任务
+     *
+     * @param runnable 任务
+     */
+    public abstract void executeOnCore(@NonNull Runnable runnable);
+
+    /**
+     * IO 密集型任务的线程池，执行任务
+     *
+     * @param runnable 任务
+     */
     public abstract void executeOnDiskIO(@NonNull Runnable runnable);
 
+    /**
+     * CPU 密集型任务的线程池，执行任务
+     *
+     * @param runnable 任务
+     */
     public abstract void executeOnCpu(@NonNull Runnable runnable);
 
+    /**
+     * UI主线程共有handler对象，执行任务
+     *
+     * @param runnable 任务
+     */
     public abstract void postToMainThread(@NonNull Runnable runnable);
 
+    /**
+     * 获取UI主线程共有handler对象
+     *
+     * @return handler对象
+     */
+    public abstract Handler getMainHandler();
+
+    /**
+     * 配合HandlerThread使用的handler【handlerThread具有自己的looper】，一般用来执行大量任务，执行任务
+     * 一般用于在一个后台线程执行同一种任务，避免线程安全问题。如数据库，文件操作，轮训操作等
+     * @param runnable 任务
+     */
+    public abstract void postIoHandler(@NonNull Runnable runnable);
+
+    /**
+     * UI主线程共有handler对象，执行任务
+     *
+     * @param runnable 任务
+     */
     public void executeOnMainThread(@NonNull Runnable runnable) {
         if (isMainThread()) {
             runnable.run();
@@ -30,5 +72,10 @@ public void executeOnMainThread(@NonNull Runnable runnable) {
         }
     }
 
+    /**
+     * 判断是否是主线程
+     *
+     * @return true
+     */
     public abstract boolean isMainThread();
 }
diff --git a/EasyExecutor/src/main/java/com/yc/easyexecutor/DefaultTaskExecutor.java b/EasyExecutor/src/main/java/com/yc/easyexecutor/DefaultTaskExecutor.java
@@ -12,10 +12,8 @@
 import java.util.concurrent.Executors;
 import java.util.concurrent.LinkedBlockingQueue;
 import java.util.concurrent.RejectedExecutionHandler;
-import java.util.concurrent.ThreadFactory;
 import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicLong;
 
 /**
  * <pre>
@@ -27,12 +25,23 @@
  *     GitHub : https://github.com/yangchong211/YCThreadPool
  * </pre>
  */
-@RestrictTo(RestrictTo.Scope.LIBRARY)
 public class DefaultTaskExecutor extends AbsTaskExecutor {
 
     private final Object mLock = new Object();
+    /**
+     * UI主线程共有handler对象
+     */
     @Nullable
     private volatile Handler mMainHandler;
+    /**
+     * 配合handlerThread使用的handler，一般用来执行大量任务
+     */
+    @Nullable
+    private volatile Handler mIoHandler;
+    /**
+     * 核心任务的线程池
+     */
+    private final ExecutorService mCoreExecutor;
     /**
      * IO 密集型任务的线程池
      */
@@ -74,15 +83,19 @@ public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
     };
 
     public DefaultTaskExecutor() {
-        mDiskIO = Executors.newFixedThreadPool(4, new ThreadFactory() {
-
-            private final AtomicLong mCount = new AtomicLong(0);
-
+        //主要是处理io密集流
+        mDiskIO = Executors.newFixedThreadPool(4, new MyThreadFactory("LoggerTask #"));
+        //处理比较核心的任务
+        mCoreExecutor = Executors.newSingleThreadExecutor(new MyThreadFactory("ScheduleTask") {
             @Override
-            public Thread newThread(@NonNull Runnable r) {
-                return new Thread(r, "LoggerTask #" + mCount.getAndIncrement());
+            public Thread newThread(Runnable r) {
+                //创建线程
+                Thread scheduleTask = new Thread(r);
+                scheduleTask.setName("ScheduleTask");
+                return scheduleTask;
             }
         });
+        //处理cpu密集任务
         mCPUThreadPoolExecutor = new ThreadPoolExecutor(
                 CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
                 mPoolWorkQueue, Executors.defaultThreadFactory(), mHandler);
@@ -91,12 +104,19 @@ public Thread newThread(@NonNull Runnable r) {
 
 
     @Override
-    public void executeOnDiskIO(Runnable runnable) {
+    public void executeOnCore(@NonNull Runnable runnable) {
         if (runnable != null && mDiskIO != null) {
             mDiskIO.execute(runnable);
         }
     }
 
+    @Override
+    public void executeOnDiskIO(@NonNull Runnable runnable) {
+        if (runnable != null && mCoreExecutor != null) {
+            mCoreExecutor.execute(runnable);
+        }
+    }
+
     @Override
     public void executeOnCpu(@NonNull Runnable runnable) {
         if (runnable != null && mCPUThreadPoolExecutor != null) {
@@ -105,19 +125,48 @@ public void executeOnCpu(@NonNull Runnable runnable) {
     }
 
     @Override
-    public void postToMainThread(Runnable runnable) {
+    public void postToMainThread(@NonNull Runnable runnable) {
+        mMainHandler = getMainHandler();
+        if (mMainHandler != null && runnable != null) {
+            mMainHandler.post(runnable);
+        }
+    }
+
+    @Override
+    public Handler getMainHandler() {
         if (mMainHandler == null) {
             synchronized (mLock) {
                 if (mMainHandler == null) {
-                    mMainHandler = new Handler(Looper.getMainLooper());
+                    mMainHandler = new SafeHandler(Looper.getMainLooper());
                 }
             }
         }
-        if (mMainHandler != null && runnable != null) {
-            mMainHandler.post(runnable);
+        return mMainHandler;
+    }
+
+    /**
+     * 使用
+     * @param runnable
+     */
+    @Override
+    public void postIoHandler(@NonNull Runnable runnable) {
+        if (mIoHandler == null){
+            synchronized (mLock) {
+                if (mIoHandler == null) {
+                    mIoHandler = TaskHandlerThread.get("postIoHandler")
+                            .getHandler("postIoHandler");
+                }
+            }
+        }
+        if (mIoHandler != null && runnable != null) {
+            mIoHandler.post(runnable);
         }
     }
 
+    /**
+     * 判断是否是主线程
+     * @return      true表示主线程
+     */
     @Override
     public boolean isMainThread() {
         return Looper.getMainLooper().getThread() == Thread.currentThread();

diff --git a/EasyExecutor/src/main/java/com/yc/easyexecutor/DelegateTaskExecutor.java b/EasyExecutor/src/main/java/com/yc/easyexecutor/DelegateTaskExecutor.java
@@ -1,7 +1,11 @@
 package com.yc.easyexecutor;
 
+import android.os.Handler;
+
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
+import androidx.lifecycle.Lifecycle;
+import androidx.lifecycle.LifecycleOwner;
 
 import java.util.concurrent.Executor;
 
@@ -35,6 +39,16 @@ public void execute(Runnable command) {
         }
     };
 
+    @NonNull
+    private static final Executor sCoreThreadExecutor = new Executor() {
+        @Override
+        public void execute(Runnable command) {
+            if (command != null) {
+                getInstance().executeOnCore(command);
+            }
+        }
+    };
+
     @NonNull
     private static final Executor sIOThreadExecutor = new Executor() {
         @Override
@@ -77,6 +91,13 @@ public void setDelegate(@Nullable AbsTaskExecutor taskExecutor) {
         mDelegate = taskExecutor == null ? mDefaultTaskExecutor : taskExecutor;
     }
 
+    @Override
+    public void executeOnCore(@NonNull Runnable runnable) {
+        if (runnable != null) {
+            mDelegate.executeOnCore(runnable);
+        }
+    }
+
     @Override
     public void executeOnDiskIO(@Nullable Runnable runnable) {
         if (runnable != null) {
@@ -98,13 +119,25 @@ public void postToMainThread(@Nullable Runnable runnable) {
         }
     }
 
+    @Override
+    public Handler getMainHandler() {
+        return mDelegate.getMainHandler();
+    }
+
+    @Override
+    public void postIoHandler(@NonNull Runnable runnable) {
+        if (runnable != null) {
+            mDelegate.postIoHandler(runnable);
+        }
+    }
+
     @Override
     public void executeOnMainThread(@NonNull Runnable runnable) {
         super.executeOnMainThread(runnable);
     }
 
     /**
-     * 使用Handler和handler处理消息
+     * 使用HandlerThread和handler处理消息
      *
      * @return MainThreadExecutor
      */
@@ -113,6 +146,16 @@ public Executor getMainThreadExecutor() {
         return sMainThreadExecutor;
     }
 
+    /**
+     * 获取核心线程池，主要是执行一些核心任务，比如初始化相关操作
+     *
+     * @return CoreThreadExecutor
+     */
+    @NonNull
+    public Executor getCoreThreadExecutor() {
+        return sCoreThreadExecutor;
+    }
+
     /**
      * 获得io密集型线程池，有好多任务其实占用的CPU time非常少，所以使用缓存线程池,基本上来着不拒
      *
@@ -142,4 +185,45 @@ public Executor getCpuThreadExecutor() {
     public boolean isMainThread() {
         return mDelegate.isMainThread();
     }
+
+
+    /**
+     * 执行有生命周期的任务
+     */
+    public Runnable postToMainThread(LifecycleOwner lifecycleOwner, Runnable runnable) {
+        LifecycleRunnable lifecycleRunnableDelegate = new LifecycleRunnable(lifecycleOwner,
+                getMainHandler(), Lifecycle.Event.ON_DESTROY,runnable);
+        mDelegate.postToMainThread(lifecycleRunnableDelegate);
+        return lifecycleRunnableDelegate;
+    }
+
+
+    /**
+     * 执行有生命周期的任务,指定Lifecycle.Event
+     */
+    public Runnable postToMainThread(LifecycleOwner lifecycleOwner,
+                                         Lifecycle.Event targetEvent,
+                                         Runnable runnable) {
+        LifecycleRunnable lifecycleRunnableDelegate = new LifecycleRunnable(lifecycleOwner,
+                getMainHandler(),targetEvent,runnable);
+        mDelegate.postToMainThread(lifecycleRunnableDelegate);
+        return lifecycleRunnableDelegate;
+    }
+
+
+    public void postToMainThread(Runnable runnable,long delayed) {
+        getMainHandler().postDelayed(runnable,delayed);
+    }
+
+    public Runnable postToMainThread(LifecycleOwner lifecycleOwner,Runnable runnable,long delayed) {
+        LifecycleRunnable lifecycleRunnableDelegate = new LifecycleRunnable(lifecycleOwner,
+                getMainHandler(),Lifecycle.Event.ON_DESTROY,runnable);
+        getMainHandler().postDelayed(lifecycleRunnableDelegate,delayed);
+        return lifecycleRunnableDelegate;
+    }
+
+    public void removeUICallback(Runnable runnable) {
+        getMainHandler().removeCallbacks(runnable);
+    }
+
 }
diff --git a/EasyExecutor/src/main/java/com/yc/easyexecutor/InterExecutorLog.java b/EasyExecutor/src/main/java/com/yc/easyexecutor/InterExecutorLog.java
@@ -0,0 +1,8 @@
+package com.yc.easyexecutor;
+
+
+public interface InterExecutorLog {
+
+    void info(String info);
+    void error(String error);
+}