添加简易版本线程池封装

Author: chongyang211

.idea/compiler.xml

@@ -0,0 +1 @@
+/build

.idea/misc.xml

@@ -0,0 +1,33 @@
+plugins {
+    id 'com.android.library'
+}
+apply from: rootProject.projectDir.absolutePath + "/yc.gradle"
+
+
+android {
+    compileSdkVersion rootProject.ext.android["compileSdkVersion"]
+    //buildToolsVersion rootProject.ext.android["buildToolsVersion"]
+    defaultConfig {
+        minSdkVersion rootProject.ext.android["minSdkVersion"]
+        targetSdkVersion rootProject.ext.android["targetSdkVersion"]
+        versionCode rootProject.ext.android["versionCode"]
+        versionName rootProject.ext.android["versionName"]
+    }
+
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
+        }
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+}
+
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation(rootProject.ext.dependencies["appcompat"])
+    implementation(rootProject.ext.dependencies["annotation"])
+}

.idea/modules.xml

@@ -0,0 +1,21 @@
+# Add project specific ProGuard rules here.
+# You can control the set of applied configuration files using the
+# proguardFiles setting in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}
+
+# Uncomment this to preserve the line number information for
+# debugging stack traces.
+#-keepattributes SourceFile,LineNumberTable
+
+# If you keep the line number information, uncomment this to
+# hide the original source file name.
+#-renamesourcefileattribute SourceFile

EasyExecutor/.gitignore

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.yc.easyexecutor">
+
+</manifest>

EasyExecutor/build.gradle

@@ -0,0 +1,34 @@
+package com.yc.easyexecutor;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.RestrictTo;
+
+/**
+ * <pre>
+ *     @author yangchong
+ *     email  : [email protected]
+ *     time   : 2019/5/11
+ *     desc   : 抽象task任务类
+ *     revise :
+ *     GitHub : https://github.com/yangchong211/YCThreadPool
+ * </pre>
+ */
+@RestrictTo(RestrictTo.Scope.LIBRARY)
+public abstract class AbsTaskExecutor {
+
+    public abstract void executeOnDiskIO(@NonNull Runnable runnable);
+
+    public abstract void executeOnCpu(@NonNull Runnable runnable);
+
+    public abstract void postToMainThread(@NonNull Runnable runnable);
+
+    public void executeOnMainThread(@NonNull Runnable runnable) {
+        if (isMainThread()) {
+            runnable.run();
+        } else {
+            postToMainThread(runnable);
+        }
+    }
+
+    public abstract boolean isMainThread();
+}

EasyExecutor/consumer-rules.pro

@@ -0,0 +1,127 @@
+package com.yc.easyexecutor;
+
+import android.os.Handler;
+import android.os.Looper;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RestrictTo;
+
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.ExecutorService;
+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>
+ *     @author yangchong
+ *     email  : [email protected]
+ *     time   : 2019/5/11
+ *     desc   : task具体实现类
+ *     revise :
+ *     GitHub : https://github.com/yangchong211/YCThreadPool
+ * </pre>
+ */
+@RestrictTo(RestrictTo.Scope.LIBRARY)
+public class DefaultTaskExecutor extends AbsTaskExecutor {
+
+    private final Object mLock = new Object();
+    @Nullable
+    private volatile Handler mMainHandler;
+    /**
+     * IO 密集型任务的线程池
+     */
+    private final ExecutorService mDiskIO;
+    /**
+     * CPU 密集型任务的线程池
+     */
+    private final ThreadPoolExecutor mCPUThreadPoolExecutor;
+    /**
+     * CPU 核数
+     */
+    private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
+    /**
+     * 线程池线程数
+     */
+    private static final int CORE_POOL_SIZE = Math.max(2, Math.min(CPU_COUNT - 1, 5));
+    /**
+     * 线程池线程数的最大值
+     */
+    private static final int MAXIMUM_POOL_SIZE = CORE_POOL_SIZE;
+    /**
+     * 线程空置回收时间
+     */
+    private static final int KEEP_ALIVE_SECONDS = 5;
+    /**
+     * 线程池队列
+     */
+    private final BlockingQueue<Runnable> mPoolWorkQueue = new LinkedBlockingQueue<>();
+    /**
+     * 这个是为了保障任务超出BlockingQueue的最大值，且线程池中的线程数已经达到MAXIMUM_POOL_SIZE时候
+     * 还有任务到来会采取任务拒绝策略，这里定义的策略就是再开一个缓存线程池去执行。
+     * 当然BlockingQueue默认的最大值是int_max，所以理论上这里是用不到的
+     */
+    private final RejectedExecutionHandler mHandler = new RejectedExecutionHandler() {
+        @Override
+        public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
+            Executors.newCachedThreadPool().execute(r);
+        }
+    };
+
+    public DefaultTaskExecutor() {
+        mDiskIO = Executors.newFixedThreadPool(4, new ThreadFactory() {
+
+            private final AtomicLong mCount = new AtomicLong(0);
+
+            @Override
+            public Thread newThread(@NonNull Runnable r) {
+                return new Thread(r, "LoggerTask #" + mCount.getAndIncrement());
+            }
+        });
+        mCPUThreadPoolExecutor = new ThreadPoolExecutor(
+                CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
+                mPoolWorkQueue, Executors.defaultThreadFactory(), mHandler);
+        mCPUThreadPoolExecutor.allowCoreThreadTimeOut(true);
+    }
+
+
+    @Override
+    public void executeOnDiskIO(Runnable runnable) {
+        if (runnable != null && mDiskIO != null) {
+            mDiskIO.execute(runnable);
+        }
+    }
+
+    @Override
+    public void executeOnCpu(@NonNull Runnable runnable) {
+        if (runnable != null && mCPUThreadPoolExecutor != null) {
+            mCPUThreadPoolExecutor.execute(runnable);
+        }
+    }
+
+    @Override
+    public void postToMainThread(Runnable runnable) {
+        if (mMainHandler == null) {
+            synchronized (mLock) {
+                if (mMainHandler == null) {
+                    mMainHandler = new Handler(Looper.getMainLooper());
+                }
+            }
+        }
+        if (mMainHandler != null && runnable != null) {
+            mMainHandler.post(runnable);
+        }
+    }
+
+    @Override
+    public boolean isMainThread() {
+        return Looper.getMainLooper().getThread() == Thread.currentThread();
+    }
+
+
+}