SingleThreadPool

public class SingleThreadPool {
    private static final Log.Tag TAG = new Log.Tag("SingleThreadPool");

    // Thread Pool
    private static final int MAX_QUEUE_SIZE = 5000;
    private static final int CORE_POOL_SIZE = 1;
    private static final int MAX_POOL_SIZE = 1;
    private static final int KEEP_ALIEVE_TIME = 5;
    private static final TimeUnit UNIT = TimeUnit.SECONDS;
    private static final BlockingQueue<Runnable> WORK_QUEUE = new LinkedBlockingQueue<Runnable>(MAX_QUEUE_SIZE);
    private static final RejectedExecutionHandler HANDLER = new ThreadPoolExecutor.DiscardPolicy();

    // Executor
    private ExecutorService mExecutorService;

    public SingleThreadPool() {
        mExecutorService = new ThreadPoolExecutor(CORE_POOL_SIZE, MAX_POOL_SIZE, KEEP_ALIEVE_TIME, UNIT, WORK_QUEUE, SingleThreadPool.highPriorityThreadFactory(), HANDLER);
    }

    @Override
    protected void finalize() throws Throwable {
        synchronized (SingleThreadPool.class) {
            clearQueue();
            shutdown();
        }
        super.finalize();
    }

    public void clearQueue() {
        if (WORK_QUEUE != null) {
            try {
                WORK_QUEUE.clear();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public int getPoolSize() {
        return WORK_QUEUE == null ? 0 : WORK_QUEUE.size();
    }

    public boolean isEmpty() {
        return WORK_QUEUE == null ? true : WORK_QUEUE.size() == 0 ? true : false;
    }

    public void shutdown() {
        if (mExecutorService != null) {
            try {
                mExecutorService.shutdown();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public <T> Future<T> submit(Callable<T> task) {
        return mExecutorService.submit(task);
    }

    public Future<?> submit(Runnable task) {
        return mExecutorService.submit(task);
    }

    public <T> Future<T> submit(Runnable task, T result) {
        return mExecutorService.submit(task, result);
    }

    public void execute(Runnable command) {
        mExecutorService.execute(command);
    }

    /**
     * The thread factory.
     */
    protected static ThreadFactory highPriorityThreadFactory() {
        return new HighPriorityThreadFactory();
    }

    private static class HighPriorityThreadFactory implements ThreadFactory {
        private static final AtomicInteger poolNumber = new AtomicInteger(1);
        private final ThreadGroup group;
        private final AtomicInteger threadNumber = new AtomicInteger(1);
        private final String namePrefix;

        HighPriorityThreadFactory() {
            SecurityManager s = System.getSecurityManager();
            group = (s != null) ? s.getThreadGroup() :
                    Thread.currentThread().getThreadGroup();
            namePrefix = "pool-" +
                    poolNumber.getAndIncrement() +
                    "-thread-";
        }

        public Thread newThread(Runnable r) {
            Thread t = new Thread(group, r,
                    namePrefix + threadNumber.getAndIncrement(),
                    0);
            if (t.isDaemon())
                t.setDaemon(false);
            if (t.getPriority() >= Thread.NORM_PRIORITY) {
                //Log.v(TAG, "thread priority is " + t.getPriority());
                t.setPriority(Thread.MAX_PRIORITY);
            }
            return t;
        }
    }
}