完善代码案例

ThreadPoolLib/build.gradle

@@ -0,0 +1,30 @@
+apply plugin: 'com.android.library'
+apply plugin: 'com.github.dcendents.android-maven'
+
+android {
+    compileSdkVersion 29
+    buildToolsVersion '29.0.0'
+
+    defaultConfig {
+        minSdkVersion 16
+        targetSdkVersion 29
+        versionCode 13
+        versionName "1.3.3"
+    }
+
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+
+}
+
+dependencies {
+    implementation fileTree(include: ['*.jar'], dir: 'libs')
+    implementation 'androidx.appcompat:appcompat:1.2.0'
+    implementation 'androidx.annotation:annotation:1.1.0'
+}
+
+

YCThreadPoolLib/src/main/java/cn/ycbjie/ycthreadpoollib/PoolThread.java → ThreadPoolLib/src/main/java/cn/ycbjie/ycthreadpoollib/PoolThread.java

@@ -17,7 +17,8 @@
 package cn.ycbjie.ycthreadpoollib;
 
 
-import android.support.annotation.NonNull;
+
+import androidx.annotation.NonNull;
 
 import java.util.concurrent.Callable;
 import java.util.concurrent.Executor;

YCThreadPoolLib/src/main/java/cn/ycbjie/ycthreadpoollib/ScheduleTask.java → ThreadPoolLib/src/main/java/cn/ycbjie/ycthreadpoollib/ScheduleTask.java

@@ -1,6 +1,7 @@
 package cn.ycbjie.ycthreadpoollib;
 
-import android.support.annotation.NonNull;
+
+import androidx.annotation.NonNull;
 
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;

YCThreadPoolLib/src/main/java/cn/ycbjie/ycthreadpoollib/deliver/AndroidDeliver.java → ThreadPoolLib/src/main/java/cn/ycbjie/ycthreadpoollib/deliver/AndroidDeliver.java

@@ -18,8 +18,8 @@
 
 import android.os.Handler;
 import android.os.Looper;
-import android.support.annotation.NonNull;
-import android.support.annotation.Nullable;
+
+import androidx.annotation.Nullable;
 
 import java.util.concurrent.Executor;
 

YCThreadPoolLib/src/main/java/cn/ycbjie/ycthreadpoollib/deliver/JavaDeliver.java → ThreadPoolLib/src/main/java/cn/ycbjie/ycthreadpoollib/deliver/JavaDeliver.java

@@ -16,8 +16,7 @@
 
 package cn.ycbjie.ycthreadpoollib.deliver;
 
-import android.support.annotation.NonNull;
-import android.support.annotation.Nullable;
+import androidx.annotation.Nullable;
 
 import java.util.concurrent.Executor;
 

YCThreadPoolLib/src/main/java/cn/ycbjie/ycthreadpoollib/factory/MyThreadFactory.java → ThreadPoolLib/src/main/java/cn/ycbjie/ycthreadpoollib/factory/MyThreadFactory.java

@@ -16,7 +16,8 @@
 
 package cn.ycbjie.ycthreadpoollib.factory;
 
-import android.support.annotation.NonNull;
+
+import androidx.annotation.NonNull;
 
 import java.util.concurrent.ThreadFactory;
 

ThreadTaskLib/.gitignore

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

ThreadTaskLib/build.gradle

@@ -0,0 +1,25 @@
+apply plugin: 'com.android.library'
+apply plugin: 'com.github.dcendents.android-maven'
+
+android {
+    compileSdkVersion 29
+
+    defaultConfig {
+        minSdkVersion 16
+        targetSdkVersion 29
+        versionCode 1
+        versionName "1.0"
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+}
+
+dependencies {
+    implementation fileTree(include: ['*.jar'], dir: 'libs')
+    implementation 'androidx.appcompat:appcompat:1.2.0'
+    implementation 'androidx.annotation:annotation:1.1.0'
+}

ThreadTaskLib/proguard-rules.pro

@@ -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

ThreadTaskLib/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="com.yc.taskscheduler"/>

ThreadTaskLib/src/main/java/com/yc/taskscheduler/AbsTaskRunnable.java

@@ -0,0 +1,111 @@
+package com.yc.taskscheduler;
+
+import android.util.Log;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
+
+
+public abstract class AbsTaskRunnable<R> implements Runnable {
+
+    private static final String TAG = "Task";
+    private AtomicBoolean mCanceledAtomic = new AtomicBoolean(false);
+    private AtomicReference<Thread> mTaskThread = new AtomicReference<>();
+
+
+    /**
+     * 异步线程处理任务，在非主线程执行
+     * @return 处理后的结果
+     * @throws InterruptedException 获取InterruptedException异常，来判断任务是否被取消
+     */
+    public abstract R doInBackground() throws InterruptedException;
+
+    /**
+     * 异步线程处理后返回的结果，在主线程执行
+     * @param result 结果
+     */
+    public abstract void onSuccess(R result);
+
+    /**
+     * 异步线程处理出现异常的回调，按需处理，未置成抽象，主线程执行
+     * @param throwable 异常
+     */
+    public void onFail(Throwable throwable){
+
+    }
+
+    /**
+     * 任务被取消的回调，主线程执行
+     *
+     */
+    public void onCancel(){
+
+    }
+
+    /**
+     * 将任务标记为取消，没法真正取消正在执行的任务，只是结果不在onSuccess里回调
+     * cancel 不一定能让任务停止，和AsyncTask同样道理，可参考
+     * {#link http://silencedut.com/2016/07/08/%E5%9F%BA%E4%BA%8E%E6%9C%80%E6%96%B0%E7%89%88%E6%9C%AC%E7%9A%84AsyncTask%E6%BA%90%E7%A0%81%E8%A7%A3%E8%AF%BB%E5%8F%8AAsyncTask%E7%9A%84%E9%BB%91%E6%9A%97%E9%9D%A2/}
+     **/
+
+    void cancel() {
+
+        this.mCanceledAtomic.set(true);
+
+        Thread t = mTaskThread.get();
+        if(t!=null) {
+            Log.d(TAG,"Task cancel: "+t.getName());
+            t.interrupt();
+        }
+
+        TaskScheduler.runOnUIThread(new Runnable() {
+            @Override
+            public void run() {
+                onCancel();
+            }
+        });
+    }
+
+    /**
+     * 任务是已取消
+     * @return 任务是否已被取消
+     */
+    public boolean isCanceled() {
+
+        return mCanceledAtomic.get();
+    }
+
+    @Override
+    public void run() {
+        try {
+
+            Log.d(TAG,"Task : "+Thread.currentThread().getName());
+            mTaskThread.compareAndSet(null,Thread.currentThread());
+
+            mCanceledAtomic.set(false);
+
+            final R result = doInBackground();
+
+            TaskScheduler.runOnUIThread(new Runnable() {
+                @Override
+                public void run() {
+                    if(!isCanceled()){
+                        onSuccess(result);
+                    }
+                }
+            });
+        }  catch (final Throwable throwable) {
+
+            Log.e(TAG,"handle background Task  error " +throwable);
+            TaskScheduler.runOnUIThread(new Runnable() {
+                @Override
+                public void run() {
+                    if(!isCanceled()){
+                        onFail(throwable);
+                    }
+                }
+            });
+        }
+    }
+
+}

ThreadTaskLib/src/main/java/com/yc/taskscheduler/InterLog.java

@@ -0,0 +1,8 @@
+package com.yc.taskscheduler;
+
+
+public interface InterLog {
+
+    void info(String info);
+    void error(String error);
+}

ThreadTaskLib/src/main/java/com/yc/taskscheduler/LifecycleRunnable.java

@@ -0,0 +1,60 @@
+package com.yc.taskscheduler;
+
+
+import android.os.Handler;
+
+import androidx.lifecycle.GenericLifecycleObserver;
+import androidx.lifecycle.Lifecycle;
+import androidx.lifecycle.LifecycleOwner;
+
+
+public class LifecycleRunnable implements Runnable {
+
+    private Runnable mOriginRunnable;
+    private LifecycleOwner mLifecycleOwner;
+    private GenericLifecycleObserver mLifecycleObserver;
+
+
+    LifecycleRunnable(LifecycleOwner lifecycleOwner, final Handler handler,
+                      final Lifecycle.Event targetEvent,
+                      final Runnable originRunnable) {
+        if(originRunnable == null || lifecycleOwner == null) {
+            return;
+        }
+        this.mLifecycleOwner = lifecycleOwner;
+        this.mOriginRunnable = originRunnable;
+        mLifecycleObserver = new GenericLifecycleObserver() {
+            @Override
+            public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
+
+                if(event == targetEvent) {
+                    if(mLifecycleOwner!=null ) {
+                        mLifecycleOwner.getLifecycle().removeObserver(this);
+                    }
+                    handler.removeCallbacks(LifecycleRunnable.this);
+                }
+            }
+        };
+        if(TaskScheduler.isMainThread()) {
+            mLifecycleOwner.getLifecycle().addObserver(mLifecycleObserver);
+        }else {
+            TaskScheduler.runOnUIThread(new Runnable() {
+                @Override
+                public void run() {
+                    mLifecycleOwner.getLifecycle().addObserver(mLifecycleObserver);
+                }
+            });
+        }
+
+    }
+
+
+    @Override
+    public void run() {
+        if(mOriginRunnable!=null && mLifecycleOwner!=null) {
+            mOriginRunnable.run();
+            mLifecycleOwner.getLifecycle().removeObserver(mLifecycleObserver);
+        }
+
+    }
+}

ThreadTaskLib/src/main/java/com/yc/taskscheduler/SafeHandler.java

@@ -0,0 +1,35 @@
+package com.yc.taskscheduler;
+
+import android.os.Handler;
+import android.os.Looper;
+import android.os.Message;
+import android.util.Log;
+
+
+public class SafeHandler extends Handler {
+
+    private static final String TAG = "SafeSchedulerHandler";
+
+    SafeHandler(Looper looper) {
+        super(looper);
+    }
+
+    SafeHandler() {
+        super();
+    }
+
+    @Override
+    public void dispatchMessage(Message msg) {
+        if (msg == null){
+            Log.d(TAG, "msg is null , return");
+            return;
+        }
+        try {
+            super.dispatchMessage(msg);
+        } catch (Exception e) {
+            Log.d(TAG, "dispatchMessage Exception " + msg + " , " + e);
+        } catch (Error error) {
+            Log.d(TAG, "dispatchMessage error " + msg + " , " + error);
+        }
+    }
+}