C++ 不同线程之间类与类之间传递参数

#include <iostream>
#include <thread>
#include <mutex>
#include <queue>

class DataQueue {
private:
    std::mutex mutex;
    std::queue<int> dataQueue;

public:
    void pushData(int data) {
        std::lock_guard<std::mutex> lock(mutex);
        dataQueue.push(data);
    }

    bool popData(int& data) {
        std::lock_guard<std::mutex> lock(mutex);
        if (!dataQueue.empty()) {
            data = dataQueue.front();
            dataQueue.pop();
            return true;
        }
        return false;
    }
};

class DataReceiver {
private:
    DataQueue& dataQueue;

public:
    DataReceiver(DataQueue& queue) : dataQueue(queue) {}

    // 循环接收数据的线程
    void receiveDataThread()
    {
        while (true)
        {
            // 模拟接收数据
            int data = 0; // 这里假设接收到的数据是整数
            // TODO: 接收数据的逻辑

            // 将接收到的数据放入队列
            dataQueue.pushData(data);
        }
    }
};

class DataProcessor {
private:
    DataQueue& dataQueue;

public:
    DataProcessor(DataQueue& queue) : dataQueue(queue) {}

    // 其他线程调用数据的函数
    void processData()
    {
        while (true)
        {
            int data;
            if (dataQueue.popData(data))
            {
                // TODO: 处理数据的逻辑
                // 在这里可以对接收到的数据进行操作

                // 示例：打印接收到的数据
                std::cout << "Received data: " << data << std::endl;
            }
        }
    }
};

int main()
{
    DataQueue dataQueue;
    DataReceiver receiver(dataQueue);
    DataProcessor processor(dataQueue);

    // 创建接收数据的线程和处理数据的线程
    std::thread receiverThread(&DataReceiver::receiveDataThread, &receiver);
    std::thread processorThread(&DataProcessor::processData, &processor);

    // 等待线程结束
    receiverThread.join();
    processorThread.join();

    return 0;
}

在上述代码中，使用了一个互斥锁 mutex 来保护 dataQueue 的访问。循环接收数据的线程将接收到的数据放入队列，而其他线程则从队列中取出数据进行处理。通过互斥锁的加锁和解锁操作，确保了对共享数据的安全访问。（比如socket 接收到的数据，放入dataQueue中，然后在其他线程调用）