Effective Modern C++: 多线程与资源互锁 [一]

 

本文将介绍C++11中实现并发以及用mutex实现资源互锁。

先强化一下并发的概念, 下图介绍了一个计算机处理恰好两个任务时的理想情景，每个任务被分为10个相等大小的 块。在一个双核机器(具有两个处理核心)上，每个任务可以在各自的处理核心上执行。在单核 机器上做任务切换时，每个任务的块交织进行。但它们中间有一小段分隔(图中所示灰色分隔 条的厚度大于双核机器的分隔条);为了实现交织进行，系统每次从一个任务切换到另一个时都 需要切换一次上下文(context switch)，任务切换也有时间开销。进行上下文的切换时，操作 系统必须为当前运行的任务保存CPU的状态和指令指针，并计算出要切换到哪个任务，并为 即将切换到的任务重新加载处理器状态。然后，CPU可能要将新任务的指令和数据的内存载 入到缓存中，这会阻止CPU执行任何指令，从而造成的更多的延迟。

 

 

c++11标准可以用std::thread实现多线程，多线程的启动有两种方式：

• join：等待线程完成，可以确保局部变量在线程完成后，才被销毁
• detach：主线程不能与之产生直接交互。也就是说，不会等待这个线程结束

Mutex：

当多个线程常出现恶性条件竞争时需要进行加锁，通常发生于完成对多于一个的数据块的修改时，例如，对两个连接指针的修改 (如图3.1)。因为操作要访问两个独立的数据块，独立的指令将会对数据块将进行修改，并且 其中一个线程可能正在进行时，另一个线程就对数据块进行了访问。

使用Mutex进行互锁：

（1）使用mutex的lock和unlock手动加锁和解锁

（2）使用lock_guard和unique_lock智能锁

详细内容看书《C++ Concurrency in Action》

示例代码:

#include <chrono>
#include <mutex>
#include <thread>
#include <iostream>

std::chrono::milliseconds interval(100);

std::mutex mutex;
int job_shared = 0; //两个线程都能修改'job_shared',mutex将保护此变量
int job_exclusive = 0; //只有一个线程能修改'job_exclusive',不需要保护

//此线程只能修改 'job_shared'
void job_1()
{
    mutex.lock();
    std::this_thread::sleep_for(5 * interval);  //令‘job_1’持锁等待
    ++job_shared;
    std::cout << "job_1 shared (" << job_shared << ")" << '\n';
    mutex.unlock();
}

// 此线程能修改'job_shared'和'job_exclusive'
void job_2()
{
    while (true) {    //无限循环，直到获得锁并修改'job_shared'
        if (mutex.try_lock()) {     //尝试获得锁成功则修改'job_shared'
            ++job_shared;
            std::cout << "job_2 shared (" << job_shared << ")\n";
            mutex.unlock();
            return;
        } else {      //尝试获得锁失败,接着修改'job_exclusive'
            ++job_exclusive;
            std::cout << "job_2 exclusive (" << job_exclusive << ")\n";
            std::this_thread::sleep_for(interval);
        }
    }
}

int main()
{
    std::thread thread_1(job_1);
    std::thread thread_2(job_2);

    thread_1.join();
    thread_2.join();

    return 0;
}

#include <chrono>
#include <mutex>
#include <thread>
#include <iostream>

std::chrono::milliseconds interval(100);

std::mutex mutex;
int job_shared = 0; //两个线程都能修改'job_shared',mutex将保护此变量
int job_exclusive = 0; //只有一个线程能修改'job_exclusive',不需要保护

void job_1() {
    std::lock_guard<std::mutex> lockg(mutex);    //获取RAII智能锁，离开作用域会自动析构解锁
    std::this_thread::sleep_for(5 * interval);  //令‘job_1’持锁等待
    ++job_shared;
    std::cout << "job_1 shared (" << job_shared << ")\n";
}

void job_2() {
    while (true) {    //无限循环，直到获得锁并修改'job_shared'
       std::unique_lock<std::mutex> ulock(mutex, std::try_to_lock);        //以尝试锁策略创建智能锁
       //尝试获得锁成功则修改'job_shared'
       if (ulock) {
           ++job_shared;
           std::cout << "job_2 shared (" << job_shared << ")\n";
           return;
       } else {      //尝试获得锁失败,接着修改'job_exclusive'
           ++job_exclusive;
           std::cout << "job_2 exclusive (" << job_exclusive << ")\n";
           std::this_thread::sleep_for(interval);
       }
   }
}

int main()
{
    std::thread thread_1(job_1);
    std::thread thread_2(job_2);

    thread_1.join();
    thread_2.join();

    return 0;
}

mutex在类内部的使用

考虑当mutex作为类内部成员的情况时，由于mutex是一个不可复制的变量，导致使用mutex的线程类不可复制，在外部构造线程时，需要用过std::ref传递引用。

示例代码：

class Point{
private:
    double x;
    double y;
    std::mutex m;
public:
    Point(double _x, double _y){
        x = _x;
        y = _y;
    }
    double calculateDistance(){
        m.lock();
        double result = pow((x*x + y*y), 0.5);
        std::cout << result << std::endl;
        m.unlock();
        return result;
    }
    void setCoordinate(double value){
        x = value;
        y = value;
    }
};

int main(){

    const int loop = 100;
    Point p(0, 0);
    std::thread threads[loop];
    for(int i=0; i<loop;){
        p.setCoordinate(++i);
        threads[i] = std::thread(&Point::calculateDistance, std::ref(p));
    }
    for(int i=0; i<loop; i++){
        threads[i].join();
    }
    return 0;
}

如果需要实现互锁的线程函数是一个const对象，需要对mutex添加std::mutable关键字，mutable修饰的成员可以在const函数中进行赋值操作

实际上，对于所有的const成员函数，如果有用于多线程的场合，都需要进行加锁处理

class Point{
private:
    double x;
    double y;
    mutable std::mutex m;
public:
    Point(double _x, double _y){
        x = _x;
        y = _y;
    }
    double calculateDistance() const{
        m.lock();
        double result = pow((x*x + y*y), 0.5);
        std::cout << result << std::endl;
        m.unlock();
        return result;
    }
    void setCoordinate(double value){
        x = value;
        y = value;
    }
};

int RunMultiThread(){

    const int loop = 100;
    Point p(0, 0);
    std::thread threads[loop];
    for(int i=0; i<loop;){
        p.setCoordinate(++i);
        threads[i] = std::thread(&Point::calculateDistance, std::ref(p));
    }
    for(int i=0; i<loop; i++){
        threads[i].join();
    }
    return 0;
}