锁（mutex）使用（c++11、c++14、c++17）

最新推荐文章于 2024-07-30 19:36:16 发布
最新推荐文章于 2024-07-30 19:36:16 发布
阅读量2.8k 收藏 6
点赞数
分类专栏： c++ 文章标签： c++ 锁 mutex
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liguan1102/article/details/116236702
版权

 

新的C++版本提供了以下锁：

mutex

(C++11)

recursive_mutex

(C++11)

shared_mutex

(C++17)

timed_mutex

(C++11)

recursive_timed_mutex

(C++11)

shared_timed_mutex

(C++14)

 

提供了以下范围锁：

 

lock_guard

(C++11)

unique_lock

(C++11)

shared_lock

(C++14)

scoped_lock

(C++17)

 

 

 

 

 

  • lock_guard范围锁，简单，只有上锁和解锁两个操作，构造函数上锁，析构函数解锁
#include <iostream>
#include <mutex>
#include <shared_mutex>
#include <thread>

using std::cin;
using std::cout;
using std::endl;

template <class T>
void lock_guard(){
	int i = 0;
	T lock;
	auto fWThread = [&i, &lock]() {
		for (int k = 0; k < 10; k++) {
			std::lock_guard<T> autolock(lock);
			int j = ++i;
			std::cout << std::this_thread::get_id() << " write: " << j << endl;
		}
	};
	std::thread w1(fWThread);
	std::thread w2(fWThread);
	w1.join();
	w2.join();
}


int main(int argc, char* argv[])
{
    ::lock_guard<std::mutex>(); 
    ::lock_guard<std::recursive_mutex>();
    ::lock_guard<std::timed_mutex>();
}

 

  • unique_lock范围锁，功能多一些，提供上锁，解锁，尝试取得锁，超时请求锁，同时也用来做写锁
#include <iostream>
#include <mutex>
#include <shared_mutex>
#include <thread>

using std::cin;
using std::cout;
using std::endl;

template <class T>
void unique_lock(){
	int i = 0;
	T lock;
	auto fWThread = [&i, &lock]() {
		for (int k = 0; k < 10; k++) {
			std::unique_lock<T> autolock(lock);
			int j = ++i;
			std::cout << std::this_thread::get_id() << " write: " << j << endl;
		}
	};
	std::thread w1(fWThread);
	std::thread w2(fWThread);
	w1.join();
	w2.join();
}

template <class T>
void unique_lock_after_time() {
	int i = 0;
	T lock;
	auto fWThread = [&i, &lock]() {
		for (int k = 0; k < 10; k++) {
			std::unique_lock<T> autolock(lock, std::chrono::milliseconds(1'000));
			int j = ++i;
			std::cout << std::this_thread::get_id() << " write: " << j << endl;
		}
	};
	std::thread w1(fWThread);
	std::thread w2(fWThread);
	w1.join();
	w2.join();
}

template <class T>
void unique_lock_until_time() {
	int i = 0;
	T lock;
	auto fWThread = [&i, &lock]() {
		for (int k = 0; k < 10; k++) {
			std::unique_lock<T> autolock(lock, std::chrono::time_point < std::chrono::high_resolution_clock >(std::chrono::milliseconds(1'000)));
			int j = ++i;
			std::cout << std::this_thread::get_id() << " write: " << j << endl;
		}
	};
	std::thread w1(fWThread);
	std::thread w2(fWThread);
	w1.join();
	w2.join();
}

int main(int argc, char* argv[])
{
    // 上锁和解锁操作，一直等待到获得锁
    ::unique_lock<std::mutex>(); 
    ::unique_lock<std::recursive_mutex>();
    ::unique_lock<std::timed_mutex>();
    ::unique_lock<std::recursive_timed_mutex>();
    ::unique_lock<std::shared_mutex>();
    ::unique_lock<std::shared_timed_mutex>();

    // 上锁和解锁操作，在一定时间内等待锁，否则超时
    ::unique_lock_after_time<std::timed_mutex>();
    ::unique_lock_after_time<std::recursive_timed_mutex>();
    ::unique_lock_after_time<std::shared_timed_mutex>();

    // 上锁和解锁操作，等待获得锁一直到某一个时间点，否则超时
    ::unique_lock_until_time<std::timed_mutex>();
    ::unique_lock_until_time<std::recursive_timed_mutex>();
    ::unique_lock_until_time<std::shared_timed_mutex>();
}

 

#include <iostream>
#include <mutex>
#include <shared_mutex>
#include <thread>

using std::cin;
using std::cout;
using std::endl;

template <class T>
void scoped_lock(){
	int i = 0;
	T lock;
	auto fWThread = [&i, &lock]() {
		for (int k = 0; k < 10; k++) {
			std::scoped_lock<T> autolock(lock);
			int j = ++i;
			std::cout << std::this_thread::get_id() << " write: " << j << endl;
		}
	};
	std::thread w1(fWThread);
	std::thread w2(fWThread);
	w1.join();
	w2.join();
}

template <class T, class U>
void scoped_lock(){
	int i = 0;
	T lock;
	U lock2;
	auto fWThread = [&i, &lock, &lock2]() {
		for (int k = 0; k < 10; k++) {
			std::scoped_lock<T, U> autolock(lock, lock2);
			int j = ++i;
			std::cout << std::this_thread::get_id() << " write: " << j << endl;
		}
	};
	std::thread w1(fWThread);
	std::thread w2(fWThread);
	w1.join();
	w2.join();
}

template <class T, class U, class V>
void scoped_lock(){
	int i = 0;
	T lock;
	U lock2;
	V lock3;
	auto fWThread = [&i, &lock, &lock2, &lock3]() {
		for (int k = 0; k < 10; k++) {
			std::scoped_lock<T, U, V> autolock(lock, lock2, lock3);
			int j = ++i;
			std::cout << std::this_thread::get_id() << " write: " << j << endl;
		}
	};
	std::thread w1(fWThread);
	std::thread w2(fWThread);
	w1.join();
	w2.join();
}

int main(int argc, char* argv[])
{
    // 上锁和解锁操作，一直等待到获得锁
    ::scoped_lock<std::mutex>(); 
    ::scoped_lock<std::recursive_mutex>();
    ::scoped_lock<std::timed_mutex>();

    // 上锁和解锁，同时对两个锁进行操作
    ::scoped_lock<std::mutex, std::mutex>();
    ::scoped_lock<std::mutex, std::recursive_mutex>();

    // 上锁和解锁，同时对三个锁进行操作
    ::scoped_lock<std::mutex, std::mutex, std::mutex>();
    ::scoped_lock<std::mutex, std::recursive_mutex, std::timed_mutex>();


    // 同理，上锁和解锁，可同时对多个锁进行操作
}

 

  • shared_lock范围锁，读锁，读锁之间无互斥关系，不需要等待。常与unique_lock（作写锁）配合使用。
    • 只能用于shared_mutex和shared_timed_mutex
    • shared_lock只有在没有写锁的情况下才能获得锁，unique_lock只有在没有读锁的情况下才能获得锁
#include <iostream>
#include <mutex>
#include <shared_mutex>
#include <thread>

using std::cin;
using std::cout;
using std::endl;

template <class T>
void share_lock() {
	int i = 0;
	T lock;
	auto fRThread = [&i, &lock]() {
		for (int k = 0; k < 10; k++) {
			std::shared_lock<T> autolock(lock);
			int j = i;
			std::cout << std::this_thread::get_id() << " read: " << j << endl;
		}
	};
	auto fWThread = [&i, &lock]() {
		for (int k = 0; k < 10; k++) {
			std::unique_lock<T> autolock(lock);
			int j = ++i;
			std::cout << std::this_thread::get_id() << " write: " << j << endl;
		}
	};
	std::thread r1(fRThread);
	std::thread w1(fWThread);
	std::thread r2(fRThread);
	r1.join();
	r2.join();
	w1.join();
}

template <class T>
void share_lock_until_time() {
	int i = 0;
	T lock;
	auto fRThread = [&i, &lock]() {
		for (int k = 0; k < 10; k++) {
			std::shared_lock<T> autolock(lock, std::chrono::time_point < std::chrono::high_resolution_clock >(std::chrono::milliseconds(1'000)));
			int j = i;
			std::cout << std::this_thread::get_id() << " read: " << j << endl;
		}
	};
	auto fWThread = [&i, &lock]() {
		for (int k = 0; k < 10; k++) {
			std::unique_lock<T> autolock(lock, std::chrono::time_point < std::chrono::high_resolution_clock >(std::chrono::milliseconds(1'000)));
			int j = ++i;
			std::cout << std::this_thread::get_id() << " write: " << j << endl;
		}
	};
	std::thread r1(fRThread);
	std::thread w1(fWThread);
	std::thread r2(fRThread);
	r1.join();
	r2.join();
	w1.join();
}

template <class T>
void share_lock_after_time() {
	int i = 0;
	T lock;
	auto fRThread = [&i, &lock]() {
		for (int k = 0; k < 10; k++) {
			std::shared_lock<T> autolock(lock, std::chrono::milliseconds(1'000));
			int j = i;
			std::cout << std::this_thread::get_id() << " read: " << j << endl;
		}
	};
	auto fWThread = [&i, &lock]() {
		for (int k = 0; k < 10; k++) {
			std::unique_lock<T> autolock(lock, std::chrono::milliseconds(1'000));
			int j = ++i;
			std::cout << std::this_thread::get_id() << " write: " << j << endl;
		}
	};
	std::thread r1(fRThread);
	std::thread w1(fWThread);
	std::thread r2(fRThread);
	r1.join();
	r2.join();
	w1.join();
}

int main(int argc, char* argv[])
{
    // 上锁和解锁操作，一直等待到获得锁
    ::share_lock<std::shared_mutex>(); 

    // 上锁和解锁操作，在一定时间内等待锁，否则超时
    ::share_lock_after_time<std::shared_timed_mutex>();

    // 上锁和解锁操作，等待获得锁一直到某一个时间点，否则超时
    ::share_lock_until_time<std::shared_timed_mutex>();
}

提供了以下同时锁多个锁（不造成死锁）：

lock

(C++11)

try_lock

(C++11)

 

 

 

std::lock: 同时给多个锁上锁

std::try_lock：尝试同时给多个锁上锁

注意：这两个方法并不会去释放锁，需要自己主动去释放

#include <iostream>
#include <mutex>
#include <shared_mutex>
#include <thread>

using std::cin;
using std::cout;
using std::endl;

template <class T, class U>
void lock(){
	int i = 0;
	T lock;
    T lock2;
    U lock3;
	auto fWThread = [&i, &lock, &lock2, &lock3]() {
		for (int k = 0; k < 10; k++) {
			std::lock(lock, lock2, lock3);
			std::lock_guard<T> l1(lock, std::adopt_lock);// make sure lock is unlock finally
			std::lock_guard<T> l2(lock2, std::adopt_lock);// make sure lock2 is unlock finally
			std::lock_guard<U> l3(lock3, std::adopt_lock);// make sure lock3 is unlock finally
			int j = ++i;
			std::cout << std::this_thread::get_id() << " write: " << j << endl;
		}
	};
	std::thread w1(fWThread);
	std::thread w2(fWThread);
	w1.join();
	w2.join();
}

template <class T, class U>
void try_lock(){
	int i = 0;
	T lock;
    T lock2;
    U lock3;
	auto fWThread = [&i, &lock, &lock2, &lock3]() {
		for (int k = 0; k < 10; k++) {
            // -1 means success
			if (-1 == std::try_lock(lock, lock2, lock3)){
			    int j = ++i;
			    std::cout << std::this_thread::get_id() << " write: " << j << endl;
				lock.unlock();
				lock2.unlock();
				lock3.unlock();
            }
            else{
			    std::cout << std::this_thread::get_id() << " get lock failed" << endl;
            }   
		}
	};
	std::thread w1(fWThread);
	std::thread w2(fWThread);
	w1.join();
	w2.join();
}

int main(int argc, char* argv[])
{
    ::lock<std::mutex, std::recursive_mutex>(); 
    ::try_lock<std::mutex, std::recursive_mutex>(); 
}

提供了以下结构体指明要对锁做的操作：

defer_lock_t

(C++11)

try_to_lock_t

(C++11)

adopt_lock_t

(C++11)

 

 

 

以下分别是上面的常量实例化

defer_lock

(C++11)

try_to_lock

(C++11)

adopt_lock

(C++11)

 

 

 

它们用于指定std::lock_guard, std::unique_lock和std::shared_lock的锁定策略。

  • std::defer_lock: 不进行上锁操作
  • std::try_to_lock: 会尝试去获得锁，不一定会获得锁，会立即返回
  • std::adopt_lock: 会认为锁已经是上锁状态了。

如：   

std::mutex lock;
// 此处构造autolock时不会对lock上锁
std::unique_lock<std::mutex> autolock(lock, std::defer_lock);
// 此处构造autolock时会尝试去获得锁，会立即返回
std::unique_lock<std::mutex> autolock(lock, std::try_to_lock);
// 此处构造autolock时会假定lock已经上锁了
std::unique_lock<std::mutex> autolock(lock, std::adopt_lock);

 

还提供了整个程序中只调用一次的接口：

once_flag

(C++11)

call_once

(C++11)

 

 

 

    once_flag用于call_once，once_flag标记是否被调用过。

        · 若被调用的函数执行过了，那么这个标记就会标记为已调用；

        · 若在调用的函数执行过程中抛出了异常，那么这个标记仍标记为未调用。

     call_once指定只需要调用一次的函数入口

#include <iostream>
#include <thread>
#include <mutex>
 
std::once_flag flag1, flag2;
 
void simple_do_once()
{
    std::call_once(flag1, [](){ std::cout << "Simple example: called once\n"; });
}
 
void may_throw_function(bool do_throw)
{
  if (do_throw) {
    std::cout << "throw: call_once will retry\n"; // this may appear more than once
    throw std::exception();
  }
  std::cout << "Didn't throw, call_once will not attempt again\n"; // guaranteed once
}
 
void do_once(bool do_throw)
{
  try {
    std::call_once(flag2, may_throw_function, do_throw);
  }
  catch (...) {
  }
}
 
int main()
{
    std::thread st1(simple_do_once);
    std::thread st2(simple_do_once);
    std::thread st3(simple_do_once);
    std::thread st4(simple_do_once);
    st1.join();
    st2.join();
    st3.join();
    st4.join();
 
    std::thread t1(do_once, true);
    std::thread t2(do_once, true);
    std::thread t3(do_once, false);
    std::thread t4(do_once, true);
    t1.join();
    t2.join();
    t3.join();
    t4.join();
}

/*
Simple example: called once
throw: call_once will retry
throw: call_once will retry
Didn't throw, call_once will not attempt again
*/

 

little丶Sunshine
关注
专栏目录
C++11多线程之mutex
独钓门前月
11-02 563
概述 mutex 类是能用于保护共享数据免受从多个线程同时访问的同步原语。 调用方线程从它成功调用 lock 或 try_lock 开始，到它调用 unlock 为止占有 mutex 。 线程占有 mutex 时，所有其他线程若试图要求 mutex 的所有权，则将阻塞（对于 lock 的调用）或收到 false 返回值（对于 try_lock ）。 调用方线程在调用 lock 或 try_lock 前必须不占有 mutex 。 mutex 既不可复制亦不可移动。 构造 //构造互斥。调用后互斥在未锁定状
C++11之超时锁timed_mutex
KingOfMyHeart的博客
08-12 471
超时锁：用来记录线程加锁 解锁 等竞争锁的过程，多用于调试多线程时使用。
C++ mutex 各种各样的互斥锁 mutex、timed_mutex、recursive_mutex、shared_mutex
最新发布
flyfish
07-30 469
flyfish
C++17 std::shared_mutex（读写锁机制）（提高并发）
Dontla的博客
05-31 2932
是C++17标准库中新增的一个类，它提供了读写锁机制，可以同时支持多个线程对同一个资源进行读操作，但只能支持一个线程对同一个资源进行写操作。如果一个线程正在进行写操作，其他线程无法进行读操作或写操作，直到写操作完成。如果多个线程同时访问被保护的资源，其中一个线程会获得锁，其他线程会被阻塞，直到获得锁的线程释放锁。可以看到，两个读线程可以同时读取共享资源，而写线程必须等待读线程结束后才能修改共享资源，这样可以避免多个线程同时写同一个资源而导致的数据竞争问题。，如果你需要对共享资源进行读写操作，可以使用。
C++11 timed_mutex
程序员Link
10-12 2143
目录一 timed_mutex二 try_lock_for三 try_lock_until四 recursive_timed_mutex五 参考 一 timed_mutex 前文C++11 std::mutex中介绍了，mutex 均具有 lock、 try_lock、unlock等成员函数。 timed_mutex 增加了带时限的 try_clock。即 try_lock_for、try_lock_until。 定义 // 头文件 <mutex> class timed_mutex
c++11并发编程历程（11）在初始化时保护共享数据、保护更少的更新数据（boost::shared_mutex）、递归锁（std::recursive_mutex）
李白
09-17 763
在锁定在恰当的粒度这篇博文里，博主分享了将共享保护数据锁定在恰当的粒度，但是有时候根本就没有一个合适的粒度级别，因为并非所有的对数据结构的访问都要求同样级别的保护，在这种情况下，使用替代机制来替代普通的std::mutex可能才是恰当的。 1、在初始化时保护共享数据 假设你有一个构造起来非常昂贵的共享资源，只有当实际需要时你才会使用。所以每个请求资源的操作首先检查它是否已经初始化（构造），如果没有则初始化之。 std::shared_ptr<some_resource> resource
【C++11并发】mutex 笔记
A_cainiao_A
01-26 1242
C++11 各种mutex和lock_guard
native-mutex:C++11 互斥体上的节点包装器
06-01
C++11 互斥体上的节点包装器。 注意力 我也为此添加了一些非常复杂的条件变量，然后意识到由于节点运行时不允许您具体指定何时创建新线程，因此使用原始条件变量会搞砸并最终停止所有处理，除非您我们已经通过一些...
C++11-14教程.pdf
12-15
本篇教程将详细介绍C++11和C++14中新增的语法规则和特性，以及一些旧特性的弃用情况，帮助程序员更好地理解和使用这些新工具。 首先，C++11对C语言的兼容性进行了优化，同时也弃用了一些特性。例如，如果一个类具有...
C++11 并发指南之std::mutex详解
08-25
C++11 中的 std::mutex 是一种基本的互斥量，提供了独占所有权的特性，即不支持递归地对 std::mutex 对象上锁。std::mutex 对象提供了 lock()、unlock() 和 try_lock() 三种成员函数，分别用于锁住、解锁和尝试锁住...
C++(17)：shared_mutex读写锁
风静如云的博客
07-10 1663
C++14通过shared_timed_mutex提供了读写锁，而C++17通过shared_mutex提供了读写锁。说实话，除了shared_timed_mutex可以在lock时传递一个timeout_duration作为最长等待时间，本人还没没弄清楚这两个读写锁在使用上有什么明显的区别：.........
c++11互斥库mutex的使用
04-09
c++11多线程库中互斥库模块的使用方式，介绍了mutex类和time_mutex类的使用方式
C++11 实现读写锁 read_write_mutex
描绘自己的王国……
09-12 6175
读写锁 read_write_mutex 对于一个数据操作，简单的分可以分为读和写。 但是经常会遇到多人同时访问一个数据的情况： 多人读 多人写 有人读，有人写 处理这种情况，常用的方式是加锁（Mutex）： 读与读之间，允许并发。 读与写，写与写之间互斥。 所以读写锁需要支持以上两种情况。 读写锁 // file: read_write_mutex.h #pragma once #in...
C++多线程快速入门（四）shared_mutex以及读写锁应用
hanhan的博客
10-24 3402
在前面的三讲中我们使用的mutex都是普通的std::mutex，这里介绍一下shared_mutex，版本为C++17 std::shared_mutex的底层实现时操作系统提供的读写锁，在读多写少的情况下，该shared_mutex比mutex更加高效。 它提供了常用的四种方法： lock和unlock分别用于获取写锁和解除写锁 lock_shared和unlock_shared分别用于获取读锁和解除读锁 写锁模式称为排他锁，读锁模式称为共享锁。 c++11和c++14标准中分别引入unique_loc
C++ 通过std::shared_lock(共享锁)和std::shared_mutex(共享互斥量)实现读写锁
zpf1813763637的博客
08-09 2120
std::shared_mutex`（共享互斥锁）和 `std::map` 结合使用的方法。`std::shared_mutex` 支持读写分离的锁策略，允许多个线程并发地读取数据，但在写入数据时会互斥锁定。`writeMap` 函数使用 `std::unique_lock` 来获得独占的写入访问权限，而 `readMap` 函数使用 `std::shared_lock` 来获得共享的读取访问权限。这样，在写入数据时会阻止其他线程的任何访问，而在读取数据时可以允许多个线程同时访问。
C++ 多线程：互斥量(mutex)
iuices的博客
02-23 2755
C++ 11中的互斥量，声明在 <mutex> 头文件中，互斥量的使用可以在各种方面，比较常用在对共享数据的读写上，如果有多个线程同时读写一个数据，那么想要保证多线程安全，就必须对共享变量的读写进行保护(上锁)，从而保证线程安全。互斥量主要有四中类型：std::mutex，最基本的 Mutex 类。std::recursive_mutex，递归 Mutex 类。std::time_mutex，限时 Mutex 类。std::recursive_timed_mutex，限时递归 Mutex 类。当
C++11多线程学习：共享资源锁
在么升龙拳的博客
01-13 474
#include <thread> // thread #include <list> // list #include <mutex> // mutex #include <algorithm> // find #include <stdio.h> // printf using namespace std; list<int> some_list; mutex some_mutex; void a.
C++11/14/17中提供的mutex系列区别
乐学吧
06-16 275
C++11/14/17中提供的mutex系列类型如下：互斥量C++版本作用mutexC++11基本的互斥量timed_mutexC++11timed_mutex带超时功能。在规定的等待时间内，没有获取锁，线程不会一直阻塞，代码会继续执行recursive_mutexC++11递归锁，允许在同一个线程中同一个互斥量多次被 lock() ，用于可能被连续多次上锁（期间未解锁）的情况，效率要比mutex低std::mutex 及其变种不允许同一个线程对互斥量多次上锁，而 std::recursive_mutex
C++ std::shared_mutex读写锁
sinat_31608641的博客
03-13 7690
一、介绍 C++17中引入std::shared_mutex std::shared_mutex用于管理可转移和共享所有权的互斥对象，适用场景比较特殊：一个或多个读线程同时读取共享资源，且只有一个写线程来修改这个资源，这种情况下才能从shared_mutex获取性能优势 互斥量管理类-锁 shared_lock是read lock。搭配std::shared_mutex使用，被锁后仍允许其他线程执行同样被shared_lock的代码。 lock_guard和unique_lock是write loc
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值