后端服务------之-----限流篇

2019独角兽企业重金招聘Python工程师标准>>>

前言

        服务开发时，提供给第三方使用，防止恶意调用，和无节制调用，暴力调用，或者瞬间大批量请求会压垮我们的服务，踏上扯皮，甩锅之路。。。

        常见的限流模式有控制并发和控制速率，一个是限制并发的数量，一个是限制并发访问的速率，另外还可以限制单位时间窗口内的请求数量。

实现

控制并发数量

    利用线程池实现

    利用线程池控制并发访问数，超出的抛出拒绝服务异常

    1、线程池配置

/**
 * 
 * 配置线程池
 * 
 * 
 * 
 * @author lli
 * 
 *
 * 
 * @version 1.0
 * 
 *
 */
@Configuration
public class ExecutorConfig {

    /** 核心线程数 线程池维护线程的最少数量. */
    private int corePoolSize = 40;
    /** 线程池维护线程的最大数量. */
    private int maxPoolSize = 60;
    /** 线程池所使用的缓冲队列. */
    private int queueCapacity = 20;

    /**
     * 
     * @description 这里我想用作限流池
     * @author lli
     * @create 2017年8月29日上午10:32:02
     * @version 1.0
     * @return
     */
    @Bean
    public Executor pool() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(corePoolSize);
        executor.setMaxPoolSize(maxPoolSize);
        executor.setQueueCapacity(queueCapacity);
        executor.setThreadNamePrefix("iflytek-pool-");
        executor.initialize();
        return executor;
    }
}

  2、service具体使用

/**
     * 限流池
     */
    @Resource
    ThreadPoolTaskExecutor pool;
@Async("pool")
    public void ansyHandle(ScanDataList scanDataList) throws Exception {
        // do something
        logger.info("限流池情况---当前活动现场数量：{},线程池最大的大小：{}",
                pool.getActiveCount(), pool.getMaxPoolSize());
    }

3、控制器调用

 @ApiOperation(value = "识别接口", notes = "识别接口")
    @RequestMapping(value = { "" }, method = RequestMethod.POST)
    public JsonResult ocr(@RequestBody ScanDataList scanDataList)
        throws Exception {

        service.ansyHandle(scanDataList);
        return new JsonResult();

    }

4、拒绝服务抛出

全局异常处理拦截（后面改成，独立的业务异常）

 /**
     * 
     * @description 系统异常 预期以外异常
     * @author lli
     * @create 2017年8月3日下午1:58:12
     * @version 1.0
     * @param ex
     * @return
     */
    @ExceptionHandler(RejectedExecutionException.class)
    @ResponseStatus(value = HttpStatus.OK)
    @ResponseBody
    public JsonResult handleRejectedExecution(Exception ex) {
        logger.error("系统异常：", ex);
        return new JsonResult(BusinessMsgEnum.FAST_ERR);
    }

    信号量机制Semaphore

public class SemaphoreTest {


  // 模拟请求线程数量
  private static final int THREAD_COUNT = 30;


  // 模拟请求线程池
  private static ExecutorService threadPool = Executors

          .newFixedThreadPool(THREAD_COUNT);


  // 信号量限流 数量为并发数10
  private static Semaphore s = new Semaphore(10);


 
  public static void main(String[] args) {

      for (int i = 0; i < THREAD_COUNT; i++) {

          threadPool.execute(new Runnable() {

              @Override

              public void run() {

                  try {
                      // int availablePermits() ：返回此信号量中当前可用的许可证数。
                      // int getQueueLength()：返回正在等待获取许可证的线程数。
                      // 可以用上面的方法判断 是否还需要处理，还是抛出 定制化更好控制
                      // 尝试获取许可，超时时间为1分钟
                      s.tryAcquire(1, TimeUnit.MINUTES); 

                      System.out.println("save data");


                  } catch (InterruptedException e) {

                  } finally {
                      // 释放许可
                      s.release();
                  }

              }

          });

      }

      threadPool.shutdown();

  }

}

代码可扩展性比用线程池更优。

参考地址：http://www.2cto.com/kf/201611/569222.html

转载于:https://my.oschina.net/chuibilong/blog/1526226