限流器（流控）+ 线程 C++实现

在C++中，你可以使用互斥锁（mutex）和条件变量（condition variable）来实现一个简单的限流器（流控）以及线程。下面是一个简单的例子，它创建了一个限流器类，该类允许一定数量的线程同时访问某个资源。

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <vector>

class RateLimiter {
public:
    RateLimiter(int max_concurrent) : max_concurrent_(max_concurrent), current_concurrent_(0) {}

    void Enter() {
        std::unique_lock<std::mutex> lock(mutex_);
        // 等待，直到当前并发数小于最大并发数
        while (current_concurrent_ >= max_concurrent_) {
            cond_.wait(lock);
        }
        // 增加当前并发数
        ++current_concurrent_;
    }

    void Leave() {
        std::unique_lock<std::mutex> lock(mutex_);
        // 减少当前并发数
        --current_concurrent_;
        // 通知其他等待的线程
        cond_.notify_one();
    }

private:
    int max_concurrent_;
    int current_concurrent_;
    std::mutex mutex_;
    std::condition_variable cond_;
};

void Worker(RateLimiter& limiter, int id) {
    limiter.Enter();
    std::cout << "Thread " << id << " is working." << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(1)); // 模拟工作
    std::cout << "Thread " << id << " finished work." << std::endl;
    limiter.Leave();
}

int main() {
    RateLimiter limiter(3); // 设置最大并发数为3
    std::vector<std::thread> threads;

    for (int i = 0; i < 10; ++i) {
        threads.emplace_back(Worker, std::ref(limiter), i);
    }

    for (auto& thread : threads) {
        thread.join();
    }

    return 0;
}

输出：

Thread 0 is working.
Thread 2 is working.
Thread 9 is working.
Thread 0 finished work.
Thread 1 is working.
Thread 9 finished work.
Thread 2 finished work.
Thread 7 is working.
Thread 8 is working.
Thread 1 finished work.
Thread 6 is working.
Thread 7 finished work.
Thread 8 finished work.
Thread 3 is working.
Thread 4 is working.
Thread 6 finished work.
Thread 5 is working.
Thread 3 finished work.
Thread 4 finished work.
Thread 5 finished work.

这个例子中，RateLimiter类使用了一个互斥锁和一个条件变量来控制对资源的并发访问。Enter方法会阻塞线程，直到当前并发数小于最大并发数。一旦线程完成工作并调用Leave方法，它会减少当前并发数并通知其他等待的线程。

在main函数中，我们创建了一个RateLimiter对象，最大并发数设置为3。然后我们创建了10个工作线程，每个线程都会尝试通过限流器来访问资源。由于限流器的限制，最多只有3个线程能够同时访问资源。其他线程将被阻塞，直到有线程完成工作并离开限流器。