finsh ThreadPool、AsyncTask

README.md

@@ -41,6 +41,10 @@ Android Notes
 11. [热修复](https://github.com/Omooo/Android-Notes/blob/master/blogs/Android/%E7%83%AD%E4%BF%AE%E5%A4%8D.md)
 12. [事件分发机制](https://github.com/Omooo/Android-Notes/blob/master/blogs/Android/%E4%BA%8B%E4%BB%B6%E5%88%86%E5%8F%91%E6%9C%BA%E5%88%B6.md)
 13. [Handler 消息循环机制](https://github.com/Omooo/Android-Notes/blob/master/blogs/Android/Handler%20%E6%B6%88%E6%81%AF%E6%9C%BA%E5%88%B6.md)
+14. [AsyncTask 源码分析](https://github.com/Omooo/Android-Notes/blob/master/blogs/Android/AsyncTask.md)
+15. [HandlerThread 源码分析](<https://github.com/Omooo/Android-Notes/blob/master/blogs/Android/HandlerThread.md>)
+16. [IntentService 源码分析](https://github.com/Omooo/Android-Notes/blob/master/blogs/Android/IntentService.md)
+17. [View 工作原理](https://github.com/Omooo/Android-Notes/blob/master/blogs/Android/View%20%E5%B7%A5%E4%BD%9C%E5%8E%9F%E7%90%86.md)
 
 ##### 性能优化
 
@@ -62,7 +66,7 @@ Android Notes
 
 [电量优化](https://github.com/Omooo/Android-Notes/blob/master/blogs/Android/%E6%80%A7%E8%83%BD%E4%BC%98%E5%8C%96/%E7%94%B5%E9%87%8F%E4%BC%98%E5%8C%96.md)
 
-#### Java
+#### Java 基础
 
 [final 你需要知道的一切](https://github.com/Omooo/Android-Notes/blob/master/blogs/Java/final.md)
 
@@ -76,10 +80,20 @@ Android Notes
 
 [异常 你需要知道的一切](https://github.com/Omooo/Android-Notes/blob/master/blogs/Java/%E5%BC%82%E5%B8%B8.md)
 
+[BIO、NIO、AIO](https://github.com/Omooo/Android-Notes/blob/master/blogs/Java/BIO%E3%80%81NIO%E3%80%81AIO.md)
+
 [UncaughtExceptionHandler](https://github.com/Omooo/Android-Notes/blob/master/blogs/Java/UncaughtExceptionHandler.md)
 
 [Java 5 - Java 10 新特性总结](https://github.com/Omooo/Android-Notes/tree/master/blogs/Java/Java%205%20-%20Java%2010%20%E6%96%B0%E7%89%B9%E6%80%A7)
 
+#### Java 并发
+
+[线程、线程池](https://github.com/Omooo/Android-Notes/blob/master/blogs/Java/%E5%B9%B6%E5%8F%91/%E7%BA%BF%E7%A8%8B%E3%80%81%E7%BA%BF%E7%A8%8B%E6%B1%A0.md)
+
+[线程生命周期](https://github.com/Omooo/Android-Notes/blob/master/blogs/Java/%E5%B9%B6%E5%8F%91/Java%20%E7%BA%BF%E7%A8%8B%E7%94%9F%E5%91%BD%E5%91%A8%E6%9C%9F.md)
+
+[并发编程的万能钥匙 - 管程 ( Monitor )](https://github.com/Omooo/Android-Notes/blob/master/blogs/Java/%E5%B9%B6%E5%8F%91/%E7%AE%A1%E7%A8%8B(Monitor).md)
+
 #### JVM
 
 [一篇文章学完 JVM 重点知识](https://github.com/Omooo/Android-Notes/blob/master/blogs/JVM/JVM.md)

blogs/Android/AsyncTask.md

@@ -4,22 +4,225 @@ AsyncTask
 
 #### 目录
 
-1. 思维导图
+1. 前言
-2. 概述
+2. 源码分析
-3. 具体使用
-4. 源码分析
-5. 参考
 
-#### 思维导图
+#### 前言
 
-#### 概述
+AsyncTask 是一个轻量级的异步任务类、抽象泛型类。现在基本上没人会用到它了，但是学习一下源码还是很有必要的。很早之前就阅读 AsyncTask 源码了，当时看的迷迷糊糊的，很大一部分原因是我对线程池以及 Future、Callable 不熟悉，所以在看源码之前，一定要熟悉这一块的知识，不熟悉的可以先看看 [线程、线程池](https://github.com/Omooo/Android-Notes/blob/master/blogs/Java/%E5%B9%B6%E5%8F%91/%E7%BA%BF%E7%A8%8B%E3%80%81%E7%BA%BF%E7%A8%8B%E6%B1%A0.md)。
 
-AsyncTask 是一个轻量级的异步任务类、抽象泛型类。
+在熟悉了 Callable、FutureTask、ArrayDeque 之后，在看 AsyncTask，简直不要太简单。
-
-#### 具体使用
 
 #### 源码分析
 
-#### 参考
+首先看一下 AsyncTask 的成员变量：
+
+```java
+    //串行的任务执行器
+		public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
+
+    private static final int MESSAGE_POST_RESULT = 0x1;
+    private static final int MESSAGE_POST_PROGRESS = 0x2;
+
+    private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
+    private static InternalHandler sHandler;
+
+		//任务队列，是 Callable 类型
+    private final WorkerRunnable<Params, Result> mWorker;
+    private final FutureTask<Result> mFuture;
+```
+
+那 SerialExecutor 到底做了什么呢？
+
+```java
+    private static class SerialExecutor implements Executor {
+        final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
+        Runnable mActive;
+
+        public synchronized void execute(final Runnable r) {
+          	//把一个任务插入到队列尾部
+            mTasks.offer(new Runnable() {
+                public void run() {
+                    try {
+                        r.run();
+                    } finally {
+                      	//当这个任务执行完毕后，再取任务队列的头部执行
+                        scheduleNext();
+                    }
+                }
+            });
+            if (mActive == null) {
+                scheduleNext();
+            }
+        }
+
+        protected synchronized void scheduleNext() {
+          	//取任务队列的头部，然后删除
+            if ((mActive = mTasks.poll()) != null) {
+                THREAD_POOL_EXECUTOR.execute(mActive);
+            }
+        }
+    }
+```
+
+所以这里就明白了，默认任务是串行执行的，越早放入的任务越早执行，同时当这个任务执行完毕之后，就会再从头部去取任务，也就达到了循环执行任务的目的了。
+
+然后就是 AsyncTask 的构造方法：
+
+```java
+    public AsyncTask() {
+        this((Looper) null);
+    }
+    public AsyncTask(@Nullable Looper callbackLooper) {
+    		//获取主线程 Handler
+    		//用于在任务执行完和任务执行过程回调函数更新进度
+        mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()
+            ? getMainHandler()
+            : new Handler(callbackLooper);
+
+        mWorker = new WorkerRunnable<Params, Result>() {
+            public Result call() throws Exception {
+                mTaskInvoked.set(true);
+                Result result = null;
+                try {
+                    Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
+                    //重写的后台操作方法
+                    result = doInBackground(mParams);
+                    Binder.flushPendingCommands();
+                } catch (Throwable tr) {
+                    mCancelled.set(true);
+                    throw tr;
+                } finally {
+                    postResult(result);
+                }
+                return result;
+            }
+        };
+
+        mFuture = new FutureTask<Result>(mWorker) {
+            @Override
+            protected void done() {
+                try {
+                    postResultIfNotInvoked(get());
+                } catch (InterruptedException e) {
+                    android.util.Log.w(LOG_TAG, e);
+                } catch (ExecutionException e) {
+                    throw new RuntimeException("An error occurred while executing doInBackground()",
+                            e.getCause());
+                } catch (CancellationException e) {
+                    postResultIfNotInvoked(null);
+                }
+            }
+        };
+    }
+```
+
+接下来就是 AsyncTask#execute() 方法：
+
+```java
+    //调用这个方法，默认是 sDefaultExecutor，也就是上面的 SerialExecutor，即串行执行
+		public final AsyncTask<Params, Progress, Result> execute(Params... params) {
+        return executeOnExecutor(sDefaultExecutor, params);
+    }
+		//当然，AsyncTask 也支持并行执行，传入 AsyncTask.THREAD_POOL_EXECUTOR
+    public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
+            Params... params) {
+        if (mStatus != Status.PENDING) {
+            switch (mStatus) {
+                case RUNNING:
+                    throw new IllegalStateException("Cannot execute task:"
+                            + " the task is already running.");
+                case FINISHED:
+                    throw new IllegalStateException("Cannot execute task:"
+                            + " the task has already been executed "
+                            + "(a task can be executed only once)");
+            }
+        }
+
+        mStatus = Status.RUNNING;
+				//重写的第一个方法
+        onPreExecute();
+
+        mWorker.mParams = params;
+      	//mFuture 是对任务队列（mWorker）的包装，可以通过 mFuture.get() 获得执行结果
+        exec.execute(mFuture);
+
+        return this;
+    }
+```
+
+我们知道，AsyncTask 的 execute 必须要在主线程中去执行，所以 onPreExecute() 也是在主线程中运行的。
+
+再回头看看 AsyncTask 在执行完任务之后调用的 postResult 方法：
+
+```java
+    private Result postResult(Result result) {
+        @SuppressWarnings("unchecked")
+        Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
+                new AsyncTaskResult<Result>(this, result));
+        message.sendToTarget();
+        return result;
+    }
+
+    protected final void publishProgress(Progress... values) {
+        if (!isCancelled()) {
+            getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
+                    new AsyncTaskResult<Progress>(this, values)).sendToTarget();
+        }
+    }
+		
+		//任务执行过程中和执行完毕的包装类
+		//mData 即执行的中间数据或执行结果
+		//mTask 即当前 AsyncTask，用于调用 finsh 和 publishProgress 方法
+    private static class AsyncTaskResult<Data> {
+        final AsyncTask mTask;
+        final Data[] mData;
+
+        AsyncTaskResult(AsyncTask task, Data... data) {
+            mTask = task;
+            mData = data;
+        }
+    }
+
+    private static class InternalHandler extends Handler {
+        public InternalHandler(Looper looper) {
+            super(looper);
+        }
+
+        @SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})
+        @Override
+        public void handleMessage(Message msg) {
+            AsyncTaskResult<?> result = (AsyncTaskResult<?>) msg.obj;
+            switch (msg.what) {
+                case MESSAGE_POST_RESULT:
+                    // 任务执行完毕回调
+                    result.mTask.finish(result.mData[0]);
+                    break;
+                case MESSAGE_POST_PROGRESS:
+                		// 任务执行过程中产生中间结果回调
+                		// 重写的更新进度方法
+                    result.mTask.onProgressUpdate(result.mData);
+                    break;
+            }
+        }
+    }
+
+    private void finish(Result result) {
+        if (isCancelled()) {
+            onCancelled(result);
+        } else {
+          	//重写的回调结果方法
+            onPostExecute(result);
+        }
+        mStatus = Status.FINISHED;
+    }
+
+
+```
+
+##### 总结
+
+首先说默认实现，即单线程线程池（SerialExecutor），它是系统全局的，也就是说每次实例化一个 AsyncTask 去执行任务的时候，都是先把任务添加到 ArrayDeque 队列尾部，然后等待上一个任务执行完毕之后，在去队列头部拿一个任务继续执行。
+任务都被封装成一个 Callable<Params,Result>，即需要获取任务执行结果，执行的时候即是调用 doInBackground 方法，关于 onPostExecute 和 onProgressUpdate 即是在执行完毕和执行过程中通过 Handler 发消息来调用。
+AsyncTask 支持多线程并发，需要使用 executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR)，传入 AsyncTask 中静态的线程池而已。
 
-[译文：Android中糟糕的AsyncTask](https://droidyue.com/blog/2014/11/08/bad-smell-of-asynctask-in-android/)

blogs/Android/Handler 消息机制.md

@@ -30,7 +30,7 @@ Android 应用是通过消息驱动运行的，在 Android 中一切皆消息，
 
 #### 基本使用
 
-基本使用不用多说，这里说一点就是尽量用第一种写法，第二种写法存在内存泄露。
+基本使用不用多说，有以下两种，但是都存在内存泄漏的情况，如何避免呢？可以通过静态内部类 + 弱引用来避免，文末常见问题汇总会有示例。
 
 ```java
     private Handler mHandler = new Handler(new Handler.Callback() {

blogs/Java/并发/线程、线程池.md

@@ -17,6 +17,8 @@ Java 线程、线程池
 
 #### 前言
 
+线程、线程池这一块，如果牵扯到并发安全，那估计就不是一篇文章能写完的了，所以本篇文章侧重复习一下基础知识，同时学习了一下 Callable 和 Future，这也是为了阅读 AsyncTask 源码打下基础。又正赶上极客时间开了《并发编程实战》一栏，补充了线程生命周期、多线程线程分配数量策略等相关知识。
+
 #### 线程
 
 ##### 线程的创建
@@ -132,6 +134,8 @@ public interface Future<V> {
 
 ##### ThreadPoolExecutor
 
+当你看到这里，我还是推荐你看：[Java并发编程：线程池的使用](https://www.cnblogs.com/dolphin0520/p/3932921.html) 这篇文章，这篇文章是我见过讲的最好的最仔细的！！！
+
 ThreadPoolExecutor 类是线程池中最核心的一个类，它提供了四个构造方法：
 
 ```java
@@ -207,7 +211,69 @@ public ThreadPoolExecutor(int corePoolSize,
 
      由调度线程处理该任务。
 
+类继承关系如下：
+
+![](https://i.loli.net/2019/03/26/5c9981d2230e8.png)
+
+这里我就拿参考文章中的示例跑了一遍：
+
+```java
+public class ThreadDemo {
+    public static void main(String[] args) throws ExecutionException, InterruptedException {
+        ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 10,
+                2, TimeUnit.SECONDS, new ArrayBlockingQueue<>(5));
+        for (int i = 0; i < 15; i++) {
+            MyTask task = new MyTask(i);
+            executor.execute(task);
+            System.out.println("线程池中线程数目: " + executor.getPoolSize() + " 队列中等待执行的任务数: "
+                    + executor.getQueue().size() + " 已执行完的任务数: " + executor.getCompletedTaskCount());
+        }
+        executor.shutdown();
+    }
+}
+
+public class MyTask implements Runnable {
+
+    private int taskName;
 
+    public MyTask(int taskName) {
+        this.taskName = taskName;
+    }
+
+    @Override
+    public void run() {
+        System.out.println("正在执行 Task: " + taskName);
+        try {
+            Thread.sleep(3000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        System.out.println("Task: " + taskName + " 执行完毕");
+    }
+}
+```
+
+当线程池中的线程数大于五时，便会将后续任务添加到任务等待队列中，当任务等待队列也满了之后，便会创建新的线程。如果将上面 for 循环改为 20，则会抛 RejectedExecutionException 任务拒绝异常。
+
+不过在 Java 中，并不会推荐直接使用 ThreadPoolExcutor，而是使用 Executors 提供的几种静态方法：
+
+```java
+    public static ExecutorService newFixedThreadPool(int nThreads) {
+        return new ThreadPoolExecutor(nThreads, nThreads,
+                                      0L, TimeUnit.MILLISECONDS,
+                                      new LinkedBlockingQueue<Runnable>());
+    public static ExecutorService newSingleThreadExecutor() {
+        return new FinalizableDelegatedExecutorService
+            (new ThreadPoolExecutor(1, 1,
+                                    0L, TimeUnit.MILLISECONDS,
+                                    new LinkedBlockingQueue<Runnable>()));
+    }
+    public static ExecutorService newCachedThreadPool() {
+        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
+                                      60L, TimeUnit.SECONDS,
+                                      new SynchronousQueue<Runnable>());
+    }
+```
 
 #### 参考