几种限流、控频策略对比

1
2
 select count(登录名) from 登录错误记录表 where 登录名='登录名' and 登录时间 > DATE_SUB(NOW(), INTERVAL 1 MINUTE)

1
2
3
4
5
6
7
8
9
## 设置key的值5秒过期
set kkk 1 EX 5
### 获取key的值
get kkk
### 自增长
incr kkk
### 手动设置过期时间
expire kkk 5

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
private boolean accessCheck(HttpSession session) {
        String key = "ACCESS"+session.getId();
        long current = 1;
        // key不存在，进行设置
        if( valueOperations.get(key) == null){
            //一步到位 
            //valueOperations.set(key,1,5,TimeUnit.SECONDS);
            // 也可以分两步设置
            valueOperations.increment(key);
            valueOperations.getOperations().expire(key,5,TimeUnit.SECONDS);
        }else {
        	// key已经存在了，自增+1
            valueOperations.increment(key);
            current = Long.parseLong(valueOperations.get(key));
        }

        if(current > 20){
            throw new RuntimeException("访问次数过于多");
        }

        return true;
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 private boolean accessCheckByLinkedList()  {
        synchronized(accessList) {
            Date data = null;
            Date now = new Date();
            if(accessList.size() > 0){
                data = accessList.getFirst();
                while (data != null && now.getTime() - data.getTime() > 5000) {
                    accessList.removeFirst();
                    if(accessList.size() > 0){
                        data = accessList.getFirst();
                    }else {
                        data = null;
                    }
                }
                if (accessList.size() > 5) {
                    throw new RuntimeException( "访问次数过于多");
                }
            }
            accessList.add(new Date());
        }
        return true;
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
public class BucketAlgorithmTest {
    public static void main(String[] args) throws InterruptedException {
        // 定时流入
        new Thread(()-> {
            while (true){
                Bucket.add();
                try {
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
        Thread.sleep(200);// 如果直接默认初始值为满的，此处可省略
        // 定时流出，模拟控制域
        new Thread(()->{
            int errorcout = 0;
            while (errorcout < 10) {
                try {
                    Bucket.get();
                    Thread.sleep(40);
                } catch (Exception e) {
                    errorcout ++;
                    e.printStackTrace();
                    try {
                        Thread.sleep(100);
                    }catch (Exception ee){

                    }
                }
            }
        }).start();
    }


}
class Bucket{
	/**
	* 当前存量
	*/
    private static Integer currentSize = 0;
    
	/**
	* 容量
	*/
    private final static int totalSize = 20;
    /**
    * 流入
    */
    public static void add(){
        synchronized (currentSize) {
            if(currentSize < totalSize) {
                currentSize++;
                System.out.println("[添加++++]可用" + Bucket.getCurrentSize());
            }
        }
    }
    /**
    * 流出
    */
    public static void get(){
        synchronized (currentSize) {
            if(currentSize > 0) {
                currentSize--;
                System.out.println("[使用---]可用" + Bucket.getCurrentSize());
            }else {
                throw new RuntimeException("当前没有剩余连接可供使用");
            }
        }
    }
    public static Integer getCurrentSize(){
        return currentSize;
    }
}