《C++并发编程实战》读书笔记（1）

这两天开始看《C++并发编程实战》一书，感觉受益匪浅啊！

按照书中的同步并发操作（第四章）的内容，尝试编写线程安全的队列，模拟固定采集时间和不确定处理时间下的队列行为，供大家参考。

用到的C++多线程相关的主要内容为：mutex类（锁对象），lock_guard模板（实现锁对象的RAII用法），unique_lock模版，condition_variable类（用于进程间等待与唤醒）

另外，书中提供了非常好的技巧，如mutex对象在类中设置为mutable（可变），以用于静态成员函数等。

上代码，线程安全队列部分参考书上写的，仅供大家学习交流。

这个是threadsafe_queue的头文件：

#ifndef SQUEUE
#define SQUEUE

#include <queue>
#include <mutex>
#include <condition_variable>
#include <memory>

template<typename T>
class threadsafe_queue{
private:
    mutable std::mutex mut;
    std::queue<T> data_queue;
    std::condition_variable data_cond;
public:
    threadsafe_queue() = default;
    threadsafe_queue(const threadsafe_queue &other){
        std::lock_guard<std::mutex> lk(other.mut);
        data_queue = other.data_queue;
    }
    threadsafe_queue &operator=(const threadsafe_queue &other){
        std::lock_guard<std::mutex> lk(other.mut);
        data_queue = other.data_queue;
    }
    void push(T new_val){
        std::lock_guard<std::mutex> lk(mut);
        data_queue.push(new_val);
        data_cond.notify_all();
    }
    void wait_and_pop(T &value){
        std::unique_lock<std::mutex> lk(mut);
        data_cond.wait(lk, [this](){return !data_queue.empty(); });
        value = data_queue.front();
        data_queue.pop();
    }
    std::shared_ptr<T> wait_and_pop(){
        std::unique_lock<std::mutex> lk(mut);
        data_cond.wait(lk, [this](){return !data_queue.empty()});
        std::shared_ptr<T> ptr(std::make_shared<T>(data_queue.front()));
        data_queue.pop();
        return ptr;
    }
    bool try_pop(T &value){
        std::lock_guard<std::mutex> lk(mut);
        if (data_queue.empty())
            return false;
        value = data_queue.front();
        data_queue.pop();
        return true;
    }
    std::shared_ptr<T> try_pop(){
        std::lock_guard<std::mutex> lk(mut);
        if (data_queue.empty())
            return std::shared_ptr<T>();
        std::shared_ptr<T> ptr(std::make_shared<T>(data_queue.front()));
        data_queue.pop();
        return ptr;
    }
    bool empty() const{
        std::lock_guard<std::mutex> lk(mut);
        return data_queue.empty();
    }
    int size() const{
        std::lock_guard<std::mutex> lk(mut);
        return data_queue.size();
    }
};

#endif

测试代码：

#include "S_queue.h"
#include <vector>
#include <iostream>
#include <thread>
#include <string>
#include <random>
#include <condition_variable>

using namespace std;

void fun1(int value, threadsafe_queue<int> &iq){
    uniform_int_distribution<int> u(-100, 100);
    default_random_engine e(time(0));
    for (int i = 0; i != value; --i){
        this_thread::sleep_for(chrono::milliseconds(100));
        iq.push(u(e));
    }
}

void fun2(int value, threadsafe_queue<int> &iq){
    uniform_int_distribution<int> u(90, 105);
    default_random_engine e(time(0));
    for (int i = 0; i != value; --i){
        this_thread::sleep_for(chrono::milliseconds(u(e)));
        int val;
        cout << "Size: " << iq.size() << " —— ";
        iq.wait_and_pop(val);
        cout << "Value: " << val << endl;
    }
}

int _tmain(int argc, _TCHAR* argv[])
{
    string line;
    threadsafe_queue<int> iq;
    int num;
    cin >> num;
    thread t1(fun1, num, ref(iq)), t2(fun2, num, ref(iq));
    t1.join();
    t2.detach();

    cin >> line;
    return 0;
}