使用Filter限制请求最大并发数

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

在开发J2EE的过程往往需要限制并发请求量从而减少服务器异常的可能性。而这些通常都是通过集群手段或外部代理来实现的。本文主要介绍单个应用如何不依赖其他程序来解决这个问题。

J2EE的每个请求都是经由过滤器（责任链模式），Servlet来执行的，每个请求的进入都需要过滤器的准许才能执行到Servlet，那么只需要在过滤器上计算当前的并发数并与最大允许数量对比即可实现并发限制。

import java.io.IOException;  
import java.util.concurrent.atomic.AtomicInteger;  
  
import javax.servlet.Filter;  
import javax.servlet.FilterChain;  
import javax.servlet.FilterConfig;  
import javax.servlet.ServletException;  
import javax.servlet.ServletRequest;  
import javax.servlet.ServletResponse;  
import javax.servlet.http.HttpServletResponse;  
  
/** 
 * 并发量计数与限制过滤器 
 * @author ZYB 
 * @date Dec 2, 2014 3:21:36 PM<BR/> 
 */  
public class ConcurrentCountFilter implements Filter{  
    // 如果不是用来限制全局并发(配置路径为/*的)的那么把static关键字去掉即可.  
    private static AtomicInteger count = new AtomicInteger(0);  
      
    /**  
     * 获取当前并发数  
     * @author ZYB  
     * @date Dec 3, 2014 9:51:37 AM<BR/>  
     * @return  
     */  
    public static int get(){  
        return count.get();  
    }  
      
    /** 
     * 增加并发数量 
     * @author ZYB 
     * @date Dec 3, 2014 9:51:32 AM<BR/> 
     * @return 
     */  
    public static int increase(){  
        return count.incrementAndGet();  
    }  
      
    /** 
     * 减少并发数量 
     * @author ZYB 
     * @date Dec 3, 2014 9:51:22 AM<BR/> 
     * @return 
     */  
    public static int decrement(){  
        return count.decrementAndGet();  
    }  
      
    /** 
     * 最大并发允许数量, 负数表示不限制 
     */  
    private int maxConcurrent = -1;  
      
    /* (non-Javadoc) 
     * @see javax.servlet.Filter#init(javax.servlet.FilterConfig) 
     */  
    @Override  
    public void init(FilterConfig filterConfig) throws ServletException {  
        String maxStr = filterConfig.getInitParameter("maxConcurrent");  
        int num = -1;  
        if(maxStr != null && !"".equals(maxStr)){  
            try{  
                num = Integer.parseInt(maxStr);  
            }catch(NumberFormatException e){}  
        }  
        if(num >= 1){  
            this.maxConcurrent = num;  
        }else{  
            this.maxConcurrent = -1;  
        }  
    }  
  
    /* (non-Javadoc) 
     * @see javax.servlet.Filter#doFilter(javax.servlet.ServletRequest, javax.servlet.ServletResponse, javax.servlet.FilterChain) 
     */  
    @Override  
    public void doFilter(ServletRequest request, ServletResponse response,  
            FilterChain chain) throws IOException, ServletException {  
        try{  
            int num = increase();//增加并发数量,并取得当前数量  
            if(maxConcurrent > 0){//检查是否限制最大并发数量, <=0表示不限制  
                if(maxConcurrent >= num){//检查是否超过最大并发限制, 没超过则允许执行  
                    chain.doFilter(request, response);  
                }else{  
                    //超过最大并发限制  
                    HttpServletResponse res = (HttpServletResponse) response;  
                    res.sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE, "达到最大并发数限制:" + this.maxConcurrent);  
                }  
            }else{//未限制最大并发数  
                chain.doFilter(request, response);  
            }  
        }finally{//由于Servlet执行时可能会抛出异常,所以使用try-finally块来减少并发数非常必要.  
            decrement();  
        }  
    }  
  
    /* (non-Javadoc) 
     * @see javax.servlet.Filter#destroy() 
     */  
    @Override  
    public void destroy() {  
    }  
  
}  

 

转载于:https://my.oschina.net/yunjie/blog/806480