1.Thread和线程池优缺点对比

1.1使用Thread

1)每次new Thread新建对象性能差；
2)线程缺乏统一管理，可能无限制新建线程，相互之间竞争，及可能占用过多系统资源导致死机或oom；
3)缺乏更多功能，如定时执行、定期执行、线程中断；

1.2使用线程池

相比new Thread，Java提供的四种线程池的好处在于：
1)重用存在的线程，减少对象创建、消亡的开销，性能佳；
2)可有效控制最大并发线程数，提高系统资源的使用率，同时避免过多资源竞争，避免堵塞；
3)提供定时执行、定期执行、单线程、并发数控制等功能；

2.实现Android高并发，可延迟处理的解决方案

2.1为什么不推荐无限制创建Thread执行

CPU之所以要增加线程数，是源于多任务处理的需要。线程数越多，越有利于同时运行多个程序，因为线程数等同于在某个瞬间CPU能同时并行处理的任务数。因此，线程数是一种逻辑的概念，简单地说，就是模拟出的 CPU 核心数。一个核心最少对应一个线程，但英特尔有个超线程技术可以把一个物理线程模拟出两个线程来用，充分发挥 CPU 性能，即一个核心可以有两个到多个线程。

2.2实现多线程并发处理解决方案

可以采用生产者，消费者的模式，生产者指需要具体执行的线程，消费者负责执行线程，将线程可以有序执行，防止线程无限制执行占用过多的资源；

以下是生产消费者队列：

生产者：将具体要执行的线程放入消息队列；

消费者：线程池负责执行将从队列中线程执行；

拒绝机制：若发现线程池已满，则执行拒绝机制，将线程放入消息队列等待，等待线程池空闲继续执行；

2.3具体实现如下：

package com.github.baby.owspace.view;import android.util.Log;import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;/*** 线程队列管理*/
public class ThreadPoolManager {private static final String TAG = ThreadPoolManager.class.getSimpleName();private static ThreadPoolManager instance = new ThreadPoolManager();public static ThreadPoolManager getInstance(){return instance;}/*** 线程池*/private ThreadPoolExecutor threadPoolExecutor;/*** 请求队列*/private LinkedBlockingDeque<Future<?>> service = new LinkedBlockingDeque<>();//线程池拒绝执行以后，放入阻塞队列private RejectedExecutionHandler handler = new RejectedExecutionHandler() {@Overridepublic void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {try {service.put(new FutureTask<Object>(r, null));} catch (InterruptedException e) {e.printStackTrace();}}};/*** 初始化*/private ThreadPoolManager(){threadPoolExecutor  = new ThreadPoolExecutor(4, 10,10, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(4), handler);threadPoolExecutor.execute(runnable);}/*** 消费者，不断检测线程队列是否有线程需要执行*/private Runnable runnable = new Runnable() {@Overridepublic void run() {while (true){FutureTask futureTask = null;try {Log.e(TAG, "队列中等待数量："+service.size());futureTask = (FutureTask)service.take();Log.e(TAG, "线程池中线程的数量："+threadPoolExecutor.getPoolSize());} catch (InterruptedException e) {e.printStackTrace();}if(futureTask !=  null){//消费需要执行的线程threadPoolExecutor.execute(futureTask);}}}};/*** 执行线程任务，延时多少秒执行，相当于生产者，把需要执行的线程放入消息队列* @param futureTask* @param delayed* @param <T>*/public <T> void execute(final FutureTask<T> futureTask, Object delayed){if(futureTask != null){//延时执行if(delayed != null){Timer timer = new Timer();timer.schedule(new TimerTask() {@Overridepublic void run() {try {service.put(futureTask);} catch (InterruptedException e) {e.printStackTrace();}}}, (long)delayed);}else {//不需要延迟处理try {service.put(futureTask);} catch (InterruptedException e) {e.printStackTrace();}}}}}

1).创建线程池和阻塞队列；

2).创建线程的消费者，负责监听阻塞队列，执行新的线程；

3).需要执行线程的地方将线程加入到阻塞队列；

4)线程池的拒绝机制处理，重新加入到阻塞队列；

2.4模拟测试多线程并发及延迟执行

public void manyRunnableTest(){//高并发for(int i=0; i<100; i++){final int finalI = i;Thread thread  = new Thread(){@Overridepublic void run() {super.run();}};ThreadPoolManager.getInstance().execute(new FutureTask<Object>(thread, null), null);}//模拟延时处理Thread thread =new Thread(){@Overridepublic void run() {super.run();Log.e(MainActivity.class.getSimpleName(), "runnable---->finalIrunnable");}};ThreadPoolManager.getInstance().execute(new FutureTask<Object>(thread,null),(long)10000);//延时执行}

参考：

https://blog.csdn.net/kerryqpw/article/details/64129583