用 C++ 算法控制员工上网的软件，关键逻辑是啥？来深度解读下

#include <iostream>
#include <queue>
#include <thread>
#include <chrono>
// 假设企业总的网络带宽，单位为字节/秒
const int TOTAL_BANDWIDTH = 100 * 1024 * 1024;  
// 员工数量，假设平均分配带宽场景，实际按需调整
const int EMPLOYEE_NUM = 50;  
// 每个员工每秒分配的令牌数，初始平均分配
const int TOKENS_PER_SECOND_PER_EMPLOYEE = TOTAL_BANDWIDTH / EMPLOYEE_NUM;  
class TokenBucket {
public:
    TokenBucket(int tokensPerSecond) : tokensPerSecond(tokensPerSecond), tokens(0) {}
    bool consume(int bytes) {
        refillTokens();
        if (tokens >= bytes) {
            tokens -= bytes;
            return true;
        }
        return false;
    }
private:
    void refillTokens() {
        // 按固定速率生成令牌
        auto now = std::chrono::steady_clock::now();
        int elapsedSeconds = std::chrono::duration_cast<std::chrono::seconds>(now - lastRefillTime).count();
        if (elapsedSeconds > 0) {
            tokens = std::min(tokens + elapsedSeconds * tokensPerSecond, MAX_TOKENS);
            lastRefillTime = now;
        }
    }
    const int tokensPerSecond;
    int tokens;
    std::chrono::steady_clock::time_point lastRefillTime = std::chrono::steady_clock::now();
    const int MAX_TOKENS = 100 * 1024 * 1024;  // 令牌桶最大容量，可按需设
};
// 为每个员工创建令牌桶实例
std::vector<TokenBucket> employeeTokenBuckets;
for (int i = 0; i < EMPLOYEE_NUM; ++i) {
    employeeTokenBuckets.push_back(TokenBucket(TOKENS_PER_SECOND_PER_EMPLOYEE));
}
// 模拟网络数据包处理线程
void packetHandler() {
    while (true) {
        // 假设每秒接收一个数据包示例，需替换为真实捕获逻辑
        int packetSize = 1024;  // 数据包大小，字节，模拟值
        int employeeId = 0;  // 简单示例，实际按IP等标识员工
        if (employeeTokenBuckets[employeeId].consume(packetSize)) {
            std::cout << "Employee " << employeeId << " packet processed successfully." << std::endl;
        } else {
            std::cout << "Employee " << employeeId << " packet dropped due to bandwidth limit." << std::endl;
        }
        std::this_thread::sleep_for(std::chrono::seconds(1));
    }
}
int main() {
    std::thread handlerThread(packetHandler);
    handlerThread.join();
    return 0;
}

#include <iostream>
#include <unordered_map>
#include <vector>
#include <ctime>
const int TIME_WINDOW_SECONDS = 900;  
struct ConnectionRecord {
    int count;
    std::vector<time_t> timestamps;
};
std::unordered_map<std::string, ConnectionRecord> employeeConnections;
void connectionMonitor(const std::string& srcIp, time_t currentTime) {
    if (employeeConnections.find(srcIp) == employeeConnections.end()) {
        ConnectionRecord record = {0, {}};
        employeeConnections[srcIp] = record;
    }
    auto& record = employeeConnections[srcIp];
    record.count++;
    record.timestamps.push_back(currentTime);
    // 清理超出时间窗口的旧连接记录
    while (!record.timestamps.empty() && (currentTime - record.timestamps.front()) > TIME_WINDOW_SECONDS) {
        record.timestamps.erase(record.timestamps.begin());
        record.count--;
    }
    if (record.count > 30) {  // 假设阈值，可依据实际调整
        std::cout << "[" << currentTime << "] Potential security threat from " << srcIp << " with excessive connections." << std::endl;
        // 实际应用中可触发阻断、告警等安全操作
    }
}
// 模拟持续接收数据包监测，需替换为真实网络嗅探
int main() {
    while (true) {
        std::string srcIp = "192.168.1.10";  // 模拟员工IP，需真实获取
        time_t currentTime = std::time(nullptr);
        connectionMonitor(srcIp, currentTime);
        std::this_thread::sleep_for(std::chrono::seconds(1));
    }
    return 0;
}