源码分享-以队列方式运行任务

     有些时候，需要用队列的方式，及先进先出，依次执行线程任务。大概场景如下：
    1. 不是很急的任务（比如提前缓存），但不能在主进程中进行（比如网络传输）；
    2.需要有顺序的执行线程任务；
    3.任务调用比较集中（某时刻突然增加大量任务，但大部分时间没有任务）；
    4.希望进程数更少的执行大量重复性任务；
    5.。。。。。。

    下面是我实现的队列线程基类，分享给大家。

import java.util.LinkedList;
import java.util.Queue;

/**
 * 以队列方式运行任务的基类
 * @param <Item>: 任务内容类
 */
public abstract class QueueRunnable<Item> implements Runnable {
    private volatile boolean mRunning = false;// 任务运行标识
    private volatile boolean mStart = true;// 进程运行标识
    private final Object mLock = new Object();// 进程锁,在没有任务时进入等待状态
    private final Queue<Item> mQueue = new LinkedList<>();// 任务队列

    /**
     * 向任务队列中添加任务
     * @param item: 要执行的任务
     */
    public void add(Item item) {
        synchronized (mQueue) {
            mQueue.add(item);
        }
        unlock();
    }

    /**
     * 从任务队列中抽取任务
     * @return : 要执行的任务
     */
    public Item poll() {
        synchronized (mQueue) {
            return mQueue.poll();
        }
    }

    /**
     * 清空任务队列
     */
    public void clear() {
        synchronized (mQueue) {
            mQueue.clear();
        }
    }

    /**
     * 获取任务队列中还没有执行的任务数量
     * @return : 任务队列大小
     */
    public int size() {
        synchronized (mQueue) {
            return mQueue.size();
        }
    }

    /**
     * 判断是否正在执行任务中
     * @return : true-正在执行任务中
     */
    public boolean isRunning() {
        return mRunning;
    }

    /**
     * 激活正在等待的进程
     */
    public void unlock() {
        synchronized (mLock) {
            mLock.notifyAll();
        }
    }

    /**
     * 关闭进程
     */
    public void stop() {
        mStart = false;
        clear();
        unlock();
    }

    /**
     * 需要子类继承实现的方法,在方法中运行具体的任务
     * @param item: 任务内容
     */
    public abstract void run(Item item);

    /**
     * 继承自Runnable,进程总运行方法
     */
    @Override
    public final void run() {
        while (mStart) {
            Item item = poll();
            if (item == null) {
                // 如果任务队列为空,进程进入等待(阻塞)状态
                try {
                    synchronized (mLock) {
                        mLock.wait();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } else {
                mRunning = true;
                run(item);
                mRunning = false;
            }
        }
    }
}