How to use?

1、first step:

copy the file "ExcuteTaskManager" and "ExcuteTask"  to your project 

2、second step:

init the library in your application or activity

ExcuteTaskManager.getInstance().init();

3、third step:

write a file extends "ExcuteTask" (eg: JsonExcuteTask)

4、fourth step:

ExcuteTaskManager.getInstance().newExcuteTask(new JsonExcuteTask());

but if you want callback , please call the method getData()

ExcuteTaskManager.getInstance().getData(new JsonExcuteTask(),
new ExcuteTaskManager.GetExcuteTaskCallback()
{
    public void onDataLoaded(ExcuteTask task)
    {
        //data has int the task, so you can update your ui;
    }
});
 

核心程式碼(Core code)

package com.rocky.eagle.task;

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


import com.rocky.eagle.utils.LogUtils;

import java.lang.ref.SoftReference;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * Start
 * <p/>
 * User:Rocky(email:
 
[email protected])
 * Created by Rocky on 2016/6/15  21:51
 * PACKAGE_NAME com.rocky.eagle.activity
 * PROJECT_NAME TaskManager
 * TODO:
 * Description:
 *
 * 使用的時候務必請先呼叫init()方法，否則不能使用
 *
 * 用最少的程式碼做盡可能多的事情
 *
 * Done
 */
public class ExcuteTaskManager implements Runnable {

    /**
     * 執行緒執行完事兒後預設的回撥型別
     */
    private static final int COMMON_EXCUTE_TASK_TYPE = 0;
    /**
     * 執行緒開關
     */
    public volatile boolean isRunning = false;
    /**
     * 是否初始化完成的開關
     */
    private boolean isHasInit = false;
    /**
     * 預設執行緒池的執行緒數量
     */
    private static final int DEFAULT_THREAD_NUM = 5;
    /**
     * 初始化時的執行緒數量
     */
    private int threadNum = DEFAULT_THREAD_NUM;
    /**
     * 定義一個單執行緒的執行緒池，專門用來執行耗時且不需要回調的操作
     */
    private static ScheduledExecutorService singlePool = null/*Executors.newSingleThreadScheduledExecutor()*/;
    /**
     * 定義一個大小為5的執行緒池(這個我們比較適合多個圖片下載時使用)
     */
    private static ExecutorService threadPool = null/*Executors.newFixedThreadPool(threadNum)*/;
    /**
     * 任務執行佇列
     */
    private static ConcurrentLinkedQueue<ExcuteTask> allExcuteTask = null/*new ConcurrentLinkedQueue<ExcuteTask>()*/;
    /**
     * 回撥介面列表
     */
    private static ConcurrentHashMap<Integer, Object> uniqueListenerList = null/*new ConcurrentHashMap<String, Object>()*/;


    public Handler getHandler() {
        return handler;
    }

    public int getThreadNum() {
        return threadNum;
    }

    public boolean isHasInit() {
        return isHasInit;
    }

    public boolean isRunning() {
        return isRunning;
    }


    /**
     * @author Rocky
     * @desc 得到普通的 ExcuteTask 物件，
     * 對外界開放的回撥介面
     */
    public interface GetExcuteTaskCallback {
        void onDataLoaded(ExcuteTask task);
    }


    /**
     * 直接把資料傳送到主執行緒
     */
    private static Handler handler = new Handler(Looper.getMainLooper()) {
        @Override
        public void handleMessage(Message msg) {
            long start = System.currentTimeMillis();
            if (msg != null && msg.obj != null
                    && msg.obj instanceof ExcuteTask) {
                switch (msg.what) {
                    case COMMON_EXCUTE_TASK_TYPE:
                        ExcuteTaskManager.getInstance().doCommonHandler((ExcuteTask) msg.obj);
                        break;
                    /** 如果想要新增其他型別的回撥，可以在此加入程式碼*/
                }
            }
            long end = System.currentTimeMillis();

            LogUtils.i(" handleMessage 總共消耗時間為：" + (end - start));
        }
    };


    private static ExcuteTaskManager instance = null;

    private ExcuteTaskManager() {
        LogUtils.i("private ExcuteTaskManager() { 當前的執行緒Id為：" + Thread.currentThread().getId());
    }

    public static ExcuteTaskManager getInstance() {
        if (instance == null) {
            synchronized (ExcuteTaskManager.class) {
                if (instance == null) {
                    instance = new ExcuteTaskManager();
                }
            }
        }
        return instance;
    }

    /**
     * 初始化操作，這個主要是初始化需要執行非同步
     * 回撥任務的執行緒池，預設開啟5個執行緒
     */
    public void init() {
        init(threadNum);
    }

    /**
     * 初始化操作，這個主要是初始化需要執行非同步
     * 回撥任務的執行緒池，可以傳入執行緒的個數
     */
    public synchronized void init(int initNum) {
        if (!isHasInit) {
            /**
             * 初始化之後就相當於開始了執行緒次的執行
             * 只不過如果沒有任務處於等待狀態
             */
            isRunning = true;
            if (initNum > 0) {
                threadNum = initNum;
            }
            threadPool = Executors.newFixedThreadPool(threadNum);
            singlePool = Executors.newSingleThreadScheduledExecutor();
            allExcuteTask = new ConcurrentLinkedQueue<>();
            uniqueListenerList = new ConcurrentHashMap<>();

            /**
             * 初始化需要用到的執行緒
             */
            for (int i = 0; i < threadNum; i++) {
                threadPool.execute(this);
            }
            isHasInit = true;
        } else {
            LogUtils.d("ExcuteTaskManager 已經初始化完成,不需要重複初始化");
        }
    }


    /**
     * 當應用被銷燬時，執行清理操作
     */
    public void doDestory() {
        /**
         * 關閉執行緒開關
         */
        isRunning = false;
        isHasInit = false;
        if (allExcuteTask != null) {
            allExcuteTask.clear();
            allExcuteTask = null;
        }
        if (uniqueListenerList != null) {
            uniqueListenerList.clear();
            uniqueListenerList = null;
        }
        if (threadPool != null) {
            threadPool.shutdown();
            threadPool = null;
        }
        if (singlePool != null) {
            singlePool.shutdown();
            singlePool = null;
        }
    }

    /**
     * 向任務佇列中新增任務物件,新增成功後,
     * 任務會自動執行,執行完事兒後,不進行任何回撥操作
     *
     * @param task 可執行的任務物件
     */
    public void newExcuteTask(ExcuteTask task) {
        if (task != null) {
            allExcuteTask.offer(task);
            LogUtils.i("ExcuteTaskManager 新增任務成功之後" + "allExcuteTask.size()=" + allExcuteTask.size());
            long timeOne = System.currentTimeMillis();
            synchronized (allExcuteTask) {
                allExcuteTask.notifyAll();
                LogUtils.i("ExcuteTaskManager =====>處於喚醒狀態");
            }
            long timeTwo = System.currentTimeMillis();
            LogUtils.i("ExcuteTaskManager喚醒執行緒所消耗的時間為：" + (timeTwo - timeOne));
        } else {
            LogUtils.w("ExcuteTaskManager====您新增的ExcuteTask為空，請重新新增");
        }
    }

    /**
     * 這個方法主要是獲取普通的回撥資料,
     * 獲取成功後會把加入的 ExcuteTask 物件回撥到使用者介面
     *
     * @param task     加入的任務Task
     * @param callback 任務的回撥介面GetDataCallback
     */
    public void getData(ExcuteTask task, GetExcuteTaskCallback callback) {
        /**
         *  把CallBack 介面加入列表中,用完之後移除
         */
        try {
            if (task != null && callback != null) {
                LogUtils.i("callback的hashcode為：" + callback.hashCode() + "task的hashcode為：" + task.hashCode());
                if (task.getUniqueID() == 0) {
                    task.setUniqueID(task.hashCode());
                }
                uniqueListenerList.put(task.getUniqueID(), callback);

                /**
                 * 開始加入任務,執行任務
                 */
                newExcuteTask(task);
            } else {
                LogUtils.w("Task 或者是 GetDataCallback 為空了,請檢查你新增的引數!");
            }
        } catch (Exception e) {
            // TODO: handle exception
            /**
             * 其實，這個地方的資料應該寫到一個檔案中
             */
            LogUtils.e("ExcuteTaskManager========getData=====" + e.toString() + " thread id 為：" + Thread.currentThread().getId());
            e.printStackTrace();
        }
    }

    /**
     * 從任務佇列中移除任務物件,使其不再執行(如果任務已經執行,則此方法無效)
     *
     * @param task 新增的任務物件
     */
    public void removeExcuteTask(ExcuteTask task) {
        if (task != null) {
            uniqueListenerList.remove(task.getUniqueID());
            allExcuteTask.remove(task);
        } else {
            LogUtils.w("ExcuteTaskManager====您所要移除的任務為null,移除失敗");
        }
    }


    /**
     * 清除所有的任務
     */
    public void removeAllExcuteTask() {
        allExcuteTask.clear();
        uniqueListenerList.clear();
    }


    /**=================================任務執行、回撥、分發start============================================*/

    /**
     * 所有的非同步任務都在此執行
     */
    @Override
    public void run() {
        // TODO Auto-generated method stub
        while (isRunning) {

            LogUtils.i("ExcuteTaskManager====準備開始執行任務 總任務個數為  allExcuteTask.size()=" + allExcuteTask.size());

            /**
             * 從allExcuteTask取任務
             */
            ExcuteTask lastExcuteTask = allExcuteTask.poll();

            LogUtils.i("ExcuteTaskManager====從allExcuteTask取出了一個任務  allExcuteTask.size()=" + allExcuteTask.size());
            if (lastExcuteTask != null) {
                try {
                    LogUtils.i("ExcuteTaskManager任務ID" + lastExcuteTask.getUniqueID());
                    /**
                     * 真正開始執行任務，
                     * 所有的耗時任務都是在子執行緒中執行
                     */
                    doExcuteTask(lastExcuteTask);
                } catch (Exception e) {
                    // TODO: handle exception
                    LogUtils.e("ExcuteTaskManager=====>執行任務發生了異常，資訊為：" + e.getMessage());
                    e.printStackTrace();
                }
                LogUtils.i("任務仍在執行,ExcuteTaskManager執行緒處於執行狀態,當前的執行緒的ID為：" + Thread.currentThread().getId());
            } else {
                LogUtils.i("任務執行完畢,ExcuteTaskManager執行緒處於等待狀態,當前的執行緒的ID為：" + Thread.currentThread().getId());
                try {
                    synchronized (allExcuteTask) {
                        allExcuteTask.wait();
                    }
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    LogUtils.e("ExcuteTaskManager=====>  執行緒等待時發生了錯誤，資訊為：" + e.getMessage());
                    e.printStackTrace();
                }
            }
        }
    }


    /**
     * 根據不同的ExcuteTask,執行相應的任務
     *
     * 這個是真正開始執行非同步任務的地方，
     * 即呼叫需要在子執行緒執行的程式碼==>task.doTask()
     *
     * @param task ExcuteTask物件
     */
    private void doExcuteTask(ExcuteTask task) {

        ExcuteTask result = task.doTask();

        /**
         *
         * 開始執行的Task和最後得到的Task是同一個的時候，才會進行回撥，
         * 否則不進行回撥(保證在回撥得到資料的時候知道是哪一個Task,以便進行強轉)
         *
         *
         * 沒有UniqueID相當於不需要回調
         *
         */
        if (result != null && task == result && result.getUniqueID() != 0) {
            /**
             *  傳送當前訊息,更新UI(把資料回撥到介面),
             *  下面不用做任何的傳送訊息，
             *  只在這一個地方傳送就行，否者會發生錯誤！
             */

            Message msg = Message.obtain();
            msg.what = COMMON_EXCUTE_TASK_TYPE;
            msg.obj = result;
            handler.sendMessage(msg);
        } else {
            uniqueListenerList.remove(task.getUniqueID());
        }
    }

    /**
     * 真正的回撥操作，所有的任務在這裡
     * 把資料回撥到主介面
     *
     * @param task ExcuteTask物件
     */
    private void doCommonHandler(ExcuteTask task) {
        long start = System.currentTimeMillis();
        LogUtils.i("已經進入了private void doCommonHandler(Message msg) {");
        if (task != null && uniqueListenerList.containsKey(task.getUniqueID())) {
            try {
                /**
                 * 回撥整個Task資料
                 * 然後可以回撥方法中去直接更新UI
                 */
                ((GetExcuteTaskCallback) uniqueListenerList.get(task.getUniqueID())).onDataLoaded(task);
                /**
                 * 回撥完成移除CallBack物件
                 */
                uniqueListenerList.remove(task.getUniqueID());
                LogUtils.i("TaskManager========doCommonHandler=====回撥成功====task 為：" + task.toString());
            } catch (Exception e) {
                // TODO: handle exception
                LogUtils.e("TaskManager========doCommonHandler=====if (uniqueListenerList.containsKey(task.getUniqueID())) {" + e.toString());
                e.printStackTrace();
            }
        } else {
            LogUtils.i("TaskManager========doCommonHandler=====已經移除了回撥監聽");
        }
        long end = System.currentTimeMillis();
        LogUtils.i("執行回撥doCommonHandler 耗時：" + (end - start));
    }
    /**=================================任務執行、回撥、分發end============================================*/


    /**=================================單執行緒池,可以順序，延遲執行一些任務start============================================*/

    /**
     * 順序執行耗時的操作
     *
     * @param runnable 物件
     */
    public void excute(Runnable runnable) {
        singlePool.execute(runnable);
    }

    /**
     * 順序執行耗時的操作
     *
     * @param runnable 物件
     * @param delay    延遲執行的時間，單位毫秒
     */
    public void excute(Runnable runnable, long delay) {
        singlePool.schedule(runnable, delay, TimeUnit.MILLISECONDS);
    }

    /**
     * 順序執行耗時的操作
     *
     * @param runnable 物件
     * @param delay    延遲執行的時間
     * @param timeUnit 時間單位
     */
    public void excute(Runnable runnable, long delay, TimeUnit timeUnit) {
        singlePool.schedule(runnable, delay, timeUnit);
    }

    public void scheduleAtFixedRate(Runnable runnable, long delay, long period, TimeUnit timeUnit) {
        singlePool.scheduleAtFixedRate(runnable, delay, period, timeUnit);
    }

    public void scheduleAtFixedRate(Runnable runnable, long delay, long period) {
        singlePool.scheduleAtFixedRate(runnable, delay, period, TimeUnit.MILLISECONDS);
    }

    public void scheduleAtFixedRate(Runnable runnable, long period) {
        singlePool.scheduleAtFixedRate(runnable, 0, period, TimeUnit.MILLISECONDS);
    }
    /**=================================單執行緒池,可以順序，延遲執行一些任務end============================================*/
}