Merge remote-tracking branch 'origin/master'

zj

2024-08-02 815342ea90c689561adeecca3230b5b5f8ddc2b7

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
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
package project.wallet.consumer;
 
import java.util.Date;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
 
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
import kernel.util.DateUtils;
import kernel.util.ThreadUtils;
import project.redis.RedisHandler;
import project.wallet.WalletRedisKeys;
 
public class WalletExtendConsumeServer {
    private static final Logger logger = LoggerFactory.getLogger(WalletExtendConsumeServer.class);
    private volatile static Map<String, Date> lastTime = new ConcurrentHashMap<String, Date>();
 
    private static ConcurrentLinkedQueue<WalletExtendMessage> WORKING_SLOW = new ConcurrentLinkedQueue<WalletExtendMessage>();
 
    private RedisHandler redisHandler;
    private WalletDao walletDao;
 
    ExecutorService FAST_THREAD = Executors.newSingleThreadExecutor();
 
    ExecutorService SLOW_THREAD = Executors.newSingleThreadExecutor();
 
    public void start() {
        FAST_THREAD.execute(new Runnable() {
            @Override
            public void run() {
 
                while (true) {
                    WalletExtendMessage item = null;
                    boolean lock = false;
                    try {
                        item = (WalletExtendMessage) redisHandler.poll(WalletRedisKeys.WALLET_EXTEND_QUEUE_UPDATE);
 
                        if (item != null) {
                            if (!WalletLockFilter.add(item.getPartyId().toString() + item.getWalletType())) {
                                WORKING_SLOW.add(item);
                                continue;
                            }
                            lock = true;
                            if (lastTime.containsKey(item.getPartyId().toString())) {
                                long millis = DateUtils.calcTimeBetweenInMillis(
                                        lastTime.get(item.getPartyId().toString()), new Date());
                                if (millis >= 100) {
                                    lastTime.put(item.getPartyId().toString(), new Date());
                                    walletDao.update(item);
                                } else {// 进入慢队列
                                    WORKING_SLOW.add(item);
                                }
 
                            } else {
                                lastTime.put(item.getPartyId().toString(), new Date());
                                walletDao.update(item);
                            }
 
                        }
 
                    } catch (Throwable e) {
                        logger.error("WalletConsumeServer FAST_THREAD() fail", e);
 
                    } finally {
                        if (item == null) {
                            ThreadUtils.sleep(100);
                        }
                        if (lock) {
                            WalletLockFilter.remove(item.getPartyId().toString() + item.getWalletType());
                        }
                    }
                }
            }
        });
 
        SLOW_THREAD.execute(new Runnable() {
            @Override
            public void run() {
 
                while (true) {
                    WalletExtendMessage item = null;
                    boolean lock = false;
                    try {
                        item = WORKING_SLOW.poll();
 
                        if (item != null) {
                            if (!WalletLockFilter.add(item.getPartyId().toString() + item.getWalletType())) {
                                WORKING_SLOW.add(item);
                                continue;
                            }
                            lock = true;
                            if (lastTime.containsKey(item.getPartyId().toString())) {
                                long millis = DateUtils.calcTimeBetweenInMillis(
                                        lastTime.get(item.getPartyId().toString()), new Date());
                                if (millis >= 100) {// 超过500毫秒则执行一次
                                    lastTime.put(item.getPartyId().toString(), new Date());
                                    walletDao.update(item);
                                } else {// 重新进入慢队列，等待下次运行
                                    WORKING_SLOW.add(item);
                                }
                            } else {
                                lastTime.put(item.getPartyId().toString(), new Date());
                                walletDao.update(item);
                            }
 
                        } else {
                            ThreadUtils.sleep(100);
                        }
 
                    } catch (Throwable e) {
                        logger.error("SmsServer taskExecutor.execute() fail", e);
 
                    } finally {
                        ThreadUtils.sleep(100);
                        if (lock) {
                            WalletLockFilter.remove(item.getPartyId().toString() + item.getWalletType());
                        }
                    }
                }
            }
        });
 
    }
 
    public void setRedisHandler(RedisHandler redisHandler) {
        this.redisHandler = redisHandler;
    }
 
    public void setWalletDao(WalletDao walletDao) {
        this.walletDao = walletDao;
    }
 
}