C++11多线程之mutex

Love The Way You Lie 2022-11-22 00:05 123阅读 0赞

### 概述 ###

`mutex` 类是能用于保护共享数据免受从多个线程同时访问的同步原语。

*  调用方线程从它成功调用 lock 或 try\_lock 开始，到它调用 unlock 为止占有 mutex 。
 *  线程占有 mutex 时，所有其他线程若试图要求 mutex 的所有权，则将阻塞（对于 lock 的调用）或收到 false 返回值（对于 try\_lock ）。
 *  调用方线程在调用 lock 或 try\_lock 前必须不占有 mutex 。

`mutex` 既不可复制亦不可移动。

### 构造 ###

//构造互斥。调用后互斥在未锁定状态。
    mutex();
    
    //复制构造函数被删除。
    mutex( const mutex& ) = delete;

### 成员函数 ###

#### lock ####

锁定互斥。若另一线程已锁定互斥，则到 `lock` 的调用将阻塞执行，直至获得锁。

**示例：**

int num = 0;
    mutex num_mutex;  //保护num
    void foo(int id)
    { 
    	for(int i = 0; i < 3; ++i)
    	{ 
    		num_mutex.lock(); //锁定
    		++num;
    		cout << id << " => " << num << endl;
    		num_mutex.unlock(); //解锁
    
    		this_thread :: sleep_for(chrono :: seconds(1));
    	}
    }
    
    int main()
    { 
    	thread t1(foo, 1);
    	thread t2(foo, 2);
    	t1.join();
    	t2.join();
    }

**输出为：**

1 => 1
    2 => 2
    1 => 3
    2 => 4
    1 => 5
    2 => 6

#### try\_lock ####

尝试锁定互斥。立即返回。成功获得锁时返回 `true` ，否则返回 `false` 。

**示例：**

//From cppreference
    std::chrono::milliseconds interval(100);
     
    std::mutex mutex;
    int job_shared = 0; // 两个线程都能修改 'job_shared',
        // mutex 将保护此变量
     
    int job_exclusive = 0; // 只有一个线程能修改 'job_exclusive'
        // 不需要保护
     
    // 此线程能修改 'job_shared' 和 'job_exclusive'
    void job_1() 
    { 
        std::this_thread::sleep_for(interval); // 令 'job_2' 持锁
     
        while (true) { 
            // 尝试锁定 mutex 以修改 'job_shared'
            if (mutex.try_lock()) { 
                std::cout << "job shared (" << job_shared << ")\n";
                mutex.unlock();
                return;
            } else { 
                // 不能获取锁以修改 'job_shared'
                // 但有其他工作可做
                ++job_exclusive;
                std::cout << "job exclusive (" << job_exclusive << ")\n";
                std::this_thread::sleep_for(interval);
            }
        }
    }
     
    // 此线程只能修改 'job_shared'
    void job_2() 
    { 
        mutex.lock();
        std::this_thread::sleep_for(5 * interval);
        ++job_shared;
        mutex.unlock();
    }
     
    int main() 
    { 
        std::thread thread_1(job_1);
        std::thread thread_2(job_2);
     
        thread_1.join();
        thread_2.join();
    }

**输出为：**

job exclusive (1)
    job exclusive (2)
    job exclusive (3)
    job exclusive (4)
    job shared (1)

#### unlock ####

解锁互斥。

互斥必须为当前执行线程所锁定，否则行为未定义。

### lock\_guard ###

类 `lock_guard` 是互斥体包装器，为在作用域块期间占有互斥提供便利 [RAII 风格][RAII]机制。

创建 `lock_guard` 对象时，它试图接收给定互斥的所有权。控制离开创建 `lock_guard` 对象的作用域时，销毁 `lock_guard` 并释放互斥。

`lock_guard` 类不可复制。

**示例：**

int num = 0;
    mutex num_mutex;  //保护num
    void foo(int id)
    { 
    	lock_guard<mutex> lock(num_mutex);
    	//num_mutex.lock(); //锁定
    	++num;
    	cout << id << " => " << num << endl;
    	//num_mutex.unlock(); //解锁
    	//离开作用域自动释放
    }
    
    int main()
    { 
    	thread t1(foo, 1);
    	thread t2(foo, 2);
    	t1.join();
    	t2.join();
    }

**输出：**

1 => 1
    2 => 2

[RAII]: https://zh.cppreference.com/w/cpp/language/raii