android实现高性能，高并发，可延时线程池管理

android实现高性能，高并发，可延时线程池管理

为什么要使用线程池？

 1.）new Thread()的缺点

• 每次new Thread()耗费性能
• 调用new Thread()创建的线程缺乏管理，被称为野线程，而且可以无限制创建，之间相互竞争，会导致过多占用系统资源导致系统瘫痪。
• 不利于扩展，比如如定时执行、定期执行、线程中断

    2.）采用线程池的优点

• 重用存在的线程，减少对象创建、消亡的开销，性能佳
• 可有效控制最大并发线程数，提高系统资源的使用率，同时避免过多资源竞争，避免堵塞
• 提供定时执行、定期执行、单线程、并发数控制等功能

线程池实现：

1.实现思路：

   使用生产者消费者模式进行设计：通过应用层给线程池提供 线程队列（生产者），线程池执行线程队列（消费者）

  由线程池设定最大线程数，当在排队的线程数超过线程池最大数量，线程池会拒绝执行，被拒绝执行的线程将被从新

  放入线程队列进行排队

   生产者：线程队列（阻塞队列）

   消费者：线程池

   拒绝机制：当排队的线程进入线程池被拒绝后，重新放入队列，重新排队

   设计思路

具体代码实现：

   ThreadPoolManager:

public class ThreadPoolManager {

   private static  ThreadPoolManager instance=new ThreadPoolManager();

    public static ThreadPoolManager getInstance() {
        return instance;
    }

    //线程池
    private ThreadPoolExecutor threadPoolExecutor;
    //请求队列
    private LinkedBlockingQueue> service=new LinkedBlockingQueue<>();

    //初始化
    private ThreadPoolManager(){
        
        threadPoolExecutor=new ThreadPoolExecutor(4,10,10, TimeUnit.SECONDS,
                new ArrayBlockingQueue(4),handler);
        
        threadPoolExecutor.execute(runnable);
    }

    //请求队列里的线程任务排队到线程池执行
    private Runnable runnable=new Runnable() {
        @Override
        public void run() {

            while (true) {     
                FutureTask futureTask = null;
       
                try {
                    Log.e("myThreadPook","service size "+service.size());
                    futureTask = (FutureTask) service.take();
                    Log.e("myThreadPook","池  "+threadPoolExecutor.getPoolSize());

                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
        
                if (futureTask != null) {
                    threadPoolExecutor.execute(futureTask);
                }
            }
        }
    };

    //执行的线程任务,延时多少秒执行
    public  void  execute(final FutureTask futureTask, Object delayed){


        if(futureTask!=null){
            try {
                //延时执行
                if(delayed!=null){
                    Timer timer=new Timer();
                    timer.schedule(new TimerTask(){
                        public void run(){
                            try {
                                service.put(futureTask);
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }

                        }},(long)delayed);
                }else {
                    service.put(futureTask);

                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }

    }

    //拒绝机制

private RejectedExecutionHandler handler=new RejectedExecutionHandler() { @Override public void rejectedExecution(Runnable runnable, ThreadPoolExecutor threadPoolExecutor) { try { service.put(new FutureTask