`
javagongchengshi
  • 浏览: 1152 次
  • 性别: Icon_minigender_1
  • 来自: 哈尔滨
最近访客 更多访客>>
文章分类
社区版块
存档分类
最新评论

java限流

 
阅读更多

public class ConcurrencyControl {

    private static ConcurrencyControl instance = new ConcurrencyControl();  

public static ConcurrencyControl getInstance(){
return instance;
}

private String preConfStr = "uws.concurrency.control.";

//并发对象
private Map<String, Object> synObjMap = new HashMap<String, Object>();
//并发量
private Map<String, Object> countMap = new HashMap<String, Object>();


private String ccfStrType = "CallCCF";
private int countForCCF = 0;
private Object ccfObj = new Object();

private String ilogStrType = "CallILOG";
private int countForILOG = 0;
private Object ilogObj = new Object();


private String taobaoRequest = "taobaoRequest";
private int taobaoCounts = 0;
private Object requestObj = new Object();


private String ccfStrTypeITS = "CallCCFForITS";
private int countForCCFITS = 0;
private Object ccfObjITS = new Object();


private String freyUndwRequest = "freyUndwRequest";
private int freyUndwCounts = 0;
private Object freyUndw = new Object();

/**
* 线程控制 未达到最大并发量,则计数器增1
* @param proType
* @param o
* @return
*/
public boolean isOverLimit(String proType, Object o) {
if (StringUtils.isEmpty(proType)) {
return false;
}
int concuLimit = getLimitCount(proType);
if (concuLimit >= 0) {
synchronized (o) {
int currentCount = getConcurrencyCount(proType);
if (currentCount >= concuLimit) {
//System.out.println(proType + "debug 最大线程数:"+concuLimit +" 当前线程数:"+currentCount);
DevLog.debug(proType + "debug 最大线程数:"+concuLimit +" 当前线程数:"+currentCount);
ErrorLogger.log(
"isOverLimit",
Level.SEVERE,
"ConcurrencyControl",
"isOverLimit",
"",
new Exception(proType + " 调用并发数已到最大值"),
ErrorLogger.saveParameters(new Object[] {
proType, concuLimit, currentCount }));
return true;
}
addConcurrencyControl(proType);
}
}
return false;
}

/**
* 释放一个线程
* @param proType
*/
public void releaseThread(String proType, Object o){
int concuLimit=0;
if(StringUtils.isEmpty(proType)){
concuLimit = -1;
}else{
concuLimit = getLimitCount(proType);
}

if (concuLimit >= 0){
synchronized (o) {
if(getConcurrencyCount(proType)>0){
decreaseConcurrencyControl(proType);
}
}
}
}

/**
* 设置已有线程数 增
* @param proType
*/
public void addConcurrencyControl(String proType) {
if(StringUtils.equals(ccfStrType, proType)){
this.countForCCF++;
}
if(StringUtils.equals(ilogStrType, proType)){
this.countForILOG++;
}
if(StringUtils.equals(taobaoRequest, proType)){
this.taobaoCounts++;
}

if(StringUtils.equals(ccfStrTypeITS, proType)){
this.countForCCFITS++;
}
if(StringUtils.equals(freyUndwRequest, proType)){
this.freyUndwCounts++;
}
}

/**
* 设置已有线程数 减
* @param proType
*/
public void decreaseConcurrencyControl(String proType) {
if(StringUtils.equals(ccfStrType, proType)){
this.countForCCF--;
}
if(StringUtils.equals(ilogStrType, proType)){
this.countForILOG--;
}
if(StringUtils.equals(taobaoRequest, proType)){
this.taobaoCounts--;
}
if(StringUtils.equals(ccfStrTypeITS, proType)){
this.countForCCFITS--;
}
if(StringUtils.equals(freyUndwRequest, proType)){
this.freyUndwCounts--;
}
}

/**
* 构造并发控制对象
*/
public ConcurrencyControl() {
synObjMap.put(ccfStrTypeITS, ccfObjITS);
synObjMap.put(ccfStrType, ccfObj);
synObjMap.put(ilogStrType, ilogObj);
synObjMap.put(taobaoRequest, requestObj);
synObjMap.put(freyUndwRequest, freyUndw);}

/**
* 获取指定的对象
* @param proType
* @return
*/
public Object getSynObjectByProType(String proType){
if(StringUtils.isNotEmpty(proType)){
return this.getSynObjMap().get(proType);
}
return new Object();
}

/**
* 获取当前线程数
* @param proType
* @return
*/
public int getConcurrencyCount(String proType) {
if(StringUtils.isNotEmpty(proType)){
return (Integer) this.getCountMap().get(proType);
}
return 0;
}

/**
* 获取最大线程数
* @param proType
* @return
*/
public int getLimitCount(String proType){
String threadNum = UWSPropertiesUtils.getPropertyValues(this.preConfStr+proType);
int limitCount = StringUtils.isBlank(threadNum) ? 5 : Integer.parseInt(threadNum);
return limitCount;
}

public Map<String, Object> getSynObjMap() {
return synObjMap;
}

public void setSynObjMap(Map<String, Object> synObjMap) {
this.synObjMap = synObjMap;
}

/**
* 获取线程控制map
* @return
*/
public Map<String, Object> getCountMap() {
countMap.put(ccfStrTypeITS, countForCCFITS);
countMap.put(ccfStrType, countForCCF);
countMap.put(ilogStrType, countForILOG);
countMap.put(taobaoRequest, taobaoCounts);
countMap.put(freyUndwRequest, freyUndwCounts);
return countMap;
}

public void setCountMap(Map<String, Object> countMap) {
this.countMap = countMap;
}

public int getCountForCCF() {
return countForCCF;
}

public void setCountForCCF(int countForCCF) {
this.countForCCF = countForCCF;
}

public Object getCcfObj() {
return ccfObj;
}

public void setCcfObj(Object ccfObj) {
this.ccfObj = ccfObj;
}

public String getCcfStrType() {
return ccfStrType;
}

public String getIlogStrType() {
return ilogStrType;
}

public void setIlogStrType(String ilogStrType) {
this.ilogStrType = ilogStrType;
}

public int getCountForILOG() {
return countForILOG;
}

public void setCountForILOG(int countForILOG) {
this.countForILOG = countForILOG;
}

public Object getIlogObj() {
return ilogObj;
}

public void setIlogObj(Object ilogObj) {
this.ilogObj = ilogObj;
}

public String getTaobaoRequest() {
return taobaoRequest;
}

public void setTaobaoRequest(String taobaoRequest) {
this.taobaoRequest = taobaoRequest;
}

public int getTaobaoCounts() {
return taobaoCounts;
}

public void setTaobaoCounts(int taobaoCounts) {
this.taobaoCounts = taobaoCounts;
}

public Object getRequestObj() {
return requestObj;
}

public void setRequestObj(Object requestObj) {
this.requestObj = requestObj;
}

public int getCountForCCFITS() {
return countForCCFITS;
}

public void setCountForCCFITS(int countForCCFITS) {
this.countForCCFITS = countForCCFITS;
}

public Object getCcfObjITS() {
return ccfObjITS;
}

public void setCcfObjITS(Object ccfObjITS) {
this.ccfObjITS = ccfObjITS;
}

public String getCcfStrTypeITS() {
return ccfStrTypeITS;
}
public String getFreyUndwRequest() {
return freyUndwRequest;
}

public void setFreyUndwRequest(String freyUndwRequest) {
this.freyUndwRequest = freyUndwRequest;
}

public int getFreyUndwCounts() {
return freyUndwCounts;
}

public void setFreyUndwCounts(int freyUndwCounts) {
this.freyUndwCounts = freyUndwCounts;
}

public Object getFreyUndw() {
return freyUndw;
}

public void setFreyUndw(Object freyUndw) {
this.freyUndw = freyUndw;
}
}
分享到:
评论

相关推荐

    Java限流实现

    本篇文章将深入探讨Java中实现限流的方法,主要围绕标题“Java限流实现”进行讲解。 限流通常有以下几种策略: 1. **固定窗口限流**:在一个设定的时间窗口内,允许固定的请求数量。如果超过这个限制,后续请求会...

    基于令牌桶算法的Java限流实现

    基于令牌桶算法的Java限流实现 在软件系统中,限流机制是一个重要的环节,它可以防止系统资源被过度使用,避免系统崩溃或性能下降。常见的限流算法有多种,如漏桶算法、令牌桶算法、滑动窗口算法等。在Java中,我们...

    java实现限流,封装的工具类

    在Java编程中,限流是一种重要的技术手段,用于控制系统的吞吐量,防止过多的请求导致服务过载或崩溃。本文将深入探讨如何利用Java实现限流,并关注于使用Semaphore作为令牌桶和漏桶算法的实现,以及在数据线程数量...

    详解Java分布式IP限流和防止恶意IP攻击方案

    Java分布式IP限流和防止恶意IP攻击方案 本文主要介绍了Java分布式IP限流和防止恶意IP攻击方案,通过示例代码详细介绍了限流和防止恶意IP攻击的实现方式。 一、分布式IP限流 分布式IP限流是分布式系统设计中经常...

    java-基于redis限流系统

    当我们谈论“java-基于redis限流系统”时,我们实际上是指利用Redis这个内存数据存储作为工具来实现Java应用的流量控制。Redis因其高效、灵活的特性,常被用于构建限流系统。下面将详细阐述这一主题。 首先,限流的...

    分布式限流面试专题系列:Nginx+zookeeper.rar

    理解和掌握Nginx、Zookeeper以及Java限流库的原理和实践,对于提升系统的健壮性以及在面试中脱颖而出都至关重要。在学习和实践中,我们需要不断探索不同场景下的最佳实践,以应对日益复杂的分布式系统挑战。

    java自定义注解接口限流demo

    java自定义注解接口限流demo; java自定义注解接口限流demo; java自定义注解接口限流demo; java自定义注解接口限流demo; java自定义注解接口限流demo; java自定义注解接口限流demo; java自定义注解接口限流demo...

    Java多线程Executors批量执行数据实现限流

    Java多线程实现数据切割批量执行,实现限流操作。 java线程池Executors实现数据批量操作。 批量异步Executors处理数据,实现限流操作,QPS限流。 线程池调用第三方接口限流实现逻辑。 案例适合: 1.批量处理大数据。...

    linux-syjratelimit无侵入的应用级网关限流框架无需配置文件细粒度控制

    标题“linux-syjratelimit无侵入的应用级网关限流框架无需配置文件细粒度控制”揭示了一个专为Linux系统设计的高级限流解决方案。该框架称为“syj-ratelimit”,它具有独特的无侵入性和高度灵活性,允许开发者在不...

    6高并发限流解决方案.xmind

    史上最全的高并发限流解决方案,xmind展示,内容直观,实践起来生动详实,希望能给各位带来帮助,欢迎下载收藏!

    java基于redis限流系统

    限流是对系统的出入流量进行控制,防止大流量出入,导致资源不足,系统不稳定。

    限流代码脚本

    在Java中,Spring Cloud Gateway 提供了RateLimiter过滤器,可以基于Guava的RateLimiter实现限流。 以下是一个简单的Python限流示例,使用了`ratelimiter`库: ```python from ratelimiter import RateLimiter # ...

    SpringBoot如何使用AOP+Redis实现接口限流实现全过程(值得珍藏)

    } } } } 3.5 拦截接口 在需要限流的接口上添加 @Aspect 和 @Around 注解,调用之前创建的 Redis 限流器进行限流检查:@RestController @RequestMapping("/api") public class MyController { @Autowired private ...

    java实现令牌桶限流

    限流是对某一时间窗口内的请求数进行限制,保持系统的可用性和稳定性,防止因流量暴增而导致的系统运行缓慢或宕机。常用的限流算法有令牌桶和和漏桶,而Google开源项目Guava中的RateLimiter使用的就是令牌桶控制算法...

    java基于redis限流系统.rar

    本项目"java基于redis限流系统"探讨的是如何利用Java编程语言和Redis缓存数据库来构建一个限流系统。下面我们将深入探讨相关知识点。 首先,我们了解下限流的基本原理。限流主要通过限制请求速率或并发量来控制系统...

    web服务器如何限流-nginx,tomcat服务器如何限制流量

    Tomcat作为Java应用服务器,它的限流通常通过修改`server.xml`中的`&lt;Connector&gt;`元素来实现。例如,我们可以设置`maxThreads`来限制处理线程的数量,从而限制并发连接数: ```xml connectionTimeout="20000" ...

    Java开发商品秒杀+限流+限时抢购+隐藏接口源码.zip

    Java开发商品秒杀+限流+限时抢购+隐藏接口源码。适用于高并发场景下商品秒杀,包含内容商品超卖问题、接口访问限流问题、Redis限时抢购、隐藏秒杀接口、单用户限制访问频率!为什么使用秒杀】 严格防止超卖 库存100...

    基于Zookeeper和guava动态限流 源码

    本文将深入探讨如何利用Zookeeper和Guava来实现动态限流,并基于提供的"基于Zookeeper和guava动态限流 源码"进行解析。我们将首先理解Zookeeper和Guava的基本概念,然后介绍它们如何协同工作以实现动态限流,最后会...

    限流aop测试代码啊啊啊啊啊啊啊啊啊啊啊啊啊啊

    限流AOP(Aspect Oriented Programming)是一种编程技术,它允许程序员定义“切面”,这些切面可以在程序执行的关键点自动插入,以实现特定的功能,如日志记录、权限检查或在本例中的流量控制。在Java开发中,Spring...

Global site tag (gtag.js) - Google Analytics