总结--异步线程、队列、函数式编程

需求：

　　将该方法的所有请求记录到数据库中，由于面向范围广（省市级），请求多（开机等）。

解决：

　　把所有进来的请求放到队列中慢慢消费（入库），多的就丢弃。

代码：

　　创建仓库类Storage实现缓冲区

public class Storage  
{  
    /**
     *  仓库最大存储量  
     */
    private final int MAX_SIZE = 300_0000;  
  
    /**
     *  仓库存储的载体  
     */
    private LinkedBlockingQueue<AAA> list = new LinkedBlockingQueue<AAA>();  
  
    public void produce(AAA aaa){  
        // 如果仓库剩余容量为0  
        if (list.size() >= MAX_SIZE) {  
            System.out.println("【库存量】:" + MAX_SIZE + "/t暂时不能执行生产任务!");  
        }else{   
            try{  
                // 放入产品，自动阻塞  
                list.put(aaa);         
            }catch (InterruptedException e){  
                e.printStackTrace();  
            }  
  
        }
    }  
 
    public LinkedBlockingQueue<AAA> getList(){  
        return list;  
    }  
  
    public void setList(LinkedBlockingQueue<AAA> list){  
        this.list = list;  
    }  
  
    public int getMAX_SIZE(){  
        return MAX_SIZE;  
    }  
}

　　仓库单例

public class StorageSingleton {
    
    private static class LazyHolder { 
        
       private static final Storage INSTANCE = new Storage();    
    } 
    
    private StorageSingleton(){}  
    
    public static final Storage getInstance() {    
       return LazyHolder.INSTANCE;    
    } 
    
}

　　消费者

public class Consumer extends Thread {　　
    private AAAService aaaService;

    private Storage storage = StorageSingleton.getInstance();
    
    private Executor executor;
    
    public Consumer() {
　　　　　// 逻辑CPU数
        int processors = Runtime.getRuntime().availableProcessors();
        // 线程池
        executor = new ThreadPoolExecutor(processors, processors*2+1, 60L, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(50_0000),
                new RejectedExecutionHandler() {
                    @Override
                    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
                        System.out.println("System busy, task count: " + executor.getTaskCount());
                    }
                });
    }
    
    @Override
    public void run() {

        try {
            while (true) {
                if (!storage.getList().isEmpty()) {
                    AAA aaa= storage.getList().take();
                    executor.execute(() -> {
                        try {                            
                            aaaService.saveAAA(aaa);
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    });
                }
                Thread.sleep(2);
            }
        } catch (Exception e) {

            e.printStackTrace();
        }
    }

    public Storage getStorage() {
        return storage;
    }

    public void setStorage(Storage storage) {
        this.storage = storage;
    }

    public AAAService getAAAService() {
        return aaaService;
    }

    public void setAAAService(AAAService aaaService) {
        this.aaaService = aaaService;
    }

}

　　储存时

 StorageSingleton.getInstance().produce(aaa);