C++ 线程 线程同步

最新推荐文章于 2024-03-03 12:41:10 发布
最新推荐文章于 2024-03-03 12:41:10 发布
阅读量2.2k 收藏 9
点赞数 1
分类专栏： 线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/langwang122/article/details/103830231
版权

当多个线程或者进程同时访问公共资源的时候就需要同步。比如说一个线程准备访问堆上的一块内存，另外的一个线程把他给释放了但是还没有来得及设置为空，那么就会出现问题，这个时候就应该线程同步，比如让第一个线程判空访问完了，第二个线程在释放置空；或者让第二个线程释放置空完了，第一个线程在进行判空访问。

简单的说线程同步就是将原本在同一时间访问同一资源的线程，让他们有时间顺序的访问资源，即确保公共资源不被同时访问。但是并不是所有的公共资源都需要同步，比如两个线程都是去只读不写某块内存，或者是具有原子性的公共资源等；加速线程则通过设计算法上避开了同时访问资源，比如多线程处理一个数组，可以第一个线程处理数组的一块，第二个线程处理数组的另一块，从而避免公共内存资源访问。

有多线程处理了公共资源的时候才需要线程同步。这里公共资源不仅仅指堆内存，文件，句柄，端口，管道，共享内存等只要能够被多个线程同时操作的都是公共资源。

线程同步的方法

在windows下，一般会有以下几种：

  1. 事件(Event);
  2. 信号量(semaphore);
  3. 互斥量(mutex);
  4. 临界区(Critical section)。

其实上述1，2，3同步的方法不仅仅是为了解决同步线程问题，更多的是为了进程间通信服务，有点像生产者消费者的意思，他是windows 内核对象，是平台相关的；临界区则是不跨进程的，所以他效率要比1，2，3的要高。（哪里有功能又多效率又高的东西了~~）。C++中的mutex底层在windows上实现就是使用的临界区。本篇主要讨论C++中的同步方法。

C++ std库提供了三类同步方法，一类是mutex，另外一个是条件变量condition_variable，还有一类是原子性

1、std::mutex的使用

不做同步的代码：


/** 不带参数的线程回调
*/
void ThreadCallBack()
{
    for (int i = 0; i < 100; ++i)
    {
        ColorPrintf(Red, "ThreadCallBack\r\n");
    }
}

int main()
{
    std::thread td(ThreadCallBack);

    for (int i = 0; i < 100; ++i)
    {
        ColorPrintf(Green, "main\r\n");
    }

    td.join();
    getchar();
    return 1;
}

结果如下：

我们发现输出的“main”和“ThreadCallBack”的颜色有红有绿，明显是线程没有同步发生了异常。我们看一下ColorPrintf的部分代码：

#define ColorPrintf(foreColor, fmt, ...)\
do {\
    HANDLE handle = ::GetStdHandle(STD_OUTPUT_HANDLE);\
    CONSOLE_SCREEN_BUFFER_INFO info;\
    if (handle != NULL && ::GetConsoleScreenBufferInfo(handle, &info))\
    {\
        ::SetConsoleTextAttribute(handle, foreColor | Black);\
        ::printf(fmt, __VA_ARGS__);\
        ::SetConsoleTextAttribute(handle, info.wAttributes);\
    }\
}while (0)

做了以下三步：

  1. 设置前景颜色
  2. 输出
  3. 将前景颜色设置回去

当子线程运行完1设置前景颜色为红色准备输出，这个时候主线程获得运行权运行了1设置了前景颜色为绿色，然后子线程抢到运行权进行输出，那么颜色就不对了，这里的控制台输出就是公共资源需要同步加锁。

同步后的代码：


#include <thread>
#include <mutex>

/** 互斥量
*/
static std::mutex s_mutex;

/** 不带参数的线程回调
*/
void ThreadCallBack()
{
    for (int i = 0; i < 100; ++i)
    {
        s_mutex.lock();
        ColorPrintf(Red, "ThreadCallBack\r\n");
        s_mutex.unlock();
    }
}

int main()
{
    std::thread td(ThreadCallBack);

    for (int i = 0; i < 100; ++i)
    {
        s_mutex.lock();
        ColorPrintf(Green, "main\r\n");
        s_mutex.unlock();
    }

    td.join();
    getchar();
    return 1;
}

结果如下：

                                          

     （上述代码输出）                                           （unlock后面加上::Sleep(1)的输出）

发现结果的颜色虽然对了，但是顺序却是先全部输出main然后输出ThreadCallBack，仔细看一下代码，发现加锁的地方也没有在循环外面啊，这是什么情况？其实将循环改为10000次的话就会出现一段绿一段红，或者在unlock后面加上::Sleep(0)。原因猜测和windows IO机制和多核cpu有关，不在本文讨论范围内。

std::recursive_mutex的使用

recursive_mutex字面理解递归互斥量。这个递归是什么意思呢？考虑std::mutex同一个线程连续调用lock的情况：一个线程lock后其他线程就会去等待这个线程unlock，但是这个线程又lock一下，自己等待自己不就死锁了（掉爆了->恢复->掉爆了0_o）?事实上如果一个线程连续两次调用mutex的lock的话会抛出异常。但一个项目可能会有很多函数都需要同步，那么多个函数嵌套调用的话基本避免不了多次lock，这个时候就可以使用recursive_mutex，他允许同一个线程多次调用lock，内部会记录调用lock次数，相应的也应该有对应次数的解锁(存疑?)，使用和mutex一样，不贴代码了。

try_lock()的使用

mutex::try_lock

在不阻止的情况下尝试获取 mutex 的所有权。


bool try_lock();

返回值
如果方法成功获取的mutex所有权, 则为 true ; 否则为false。

备注
如果调用线程已拥有 mutex，则该行为不确定。

lock函数，如果另外一个线程已经lock了那么本线程就会一直阻塞在那里，直到获得所有权。有的时候我们不希望线程阻塞，而是希望获取不到所有权的时候执行另外一段代码，可以使用try_lock()比如：

void wait()
{
    while (!s_mutex.try_lock())
    {
        // do somethings
    }
}

如果获取所有权失败了，就做一些其他事情，然后再次尝试获取所有权。当然wait只是一个例子，不是正规用法。

另外不要想着用try_lock来代替std::recursive_mutex，备注中已经说了，如果本线程已经获取的所有权，再次try_lock会发生未定义行为（UB）。

smart_lock（RAII）

mutex要求lock/unlock必须成对出现，就好像new一个对象就要delete一样，这个时候很容易想到用智能指针管理，防止忘记delete。那么对于mutex我们当然可以自己定一个类，在构造的时候lock，析构的时候unlock，std提供了这样的类，所以就不用自己重新写了~~

1、std::lock_guard

		// CLASS TEMPLATE lock_guard
template<class _Mutex>
	class lock_guard
	{	// class with destructor that unlocks a mutex
public:
	using mutex_type = _Mutex;

	explicit lock_guard(_Mutex& _Mtx)
		: _MyMutex(_Mtx)
		{	// construct and lock
		_MyMutex.lock();
		}

	lock_guard(_Mutex& _Mtx, adopt_lock_t)
		: _MyMutex(_Mtx)
		{	// construct but don't lock
		}

	~lock_guard() noexcept
		{	// unlock
		_MyMutex.unlock();
		}

	lock_guard(const lock_guard&) = delete;
	lock_guard& operator=(const lock_guard&) = delete;
private:
	_Mutex& _MyMutex;
	};

上述代码是windows下的一个std::lock_guard的实现，可以看到他在析构的时候unlock。同时他还提供一个构造时候不调用lock的构造函数，有时候也会用到。需要注意的是这个类没有拷贝/赋值构造函数，有右值构造，但是不建议使用，同时也不建议在堆上创建对象。示例：


/** 互斥量
*/
static std::mutex s_mutex;

/** 不带参数的线程回调
*/
void ThreadCallBack()
{
    for (int i = 0; i < 100; ++i)
    {
        std::lock_guard<std::mutex> lockGuard(s_mutex);
        ColorPrintf(Red, "ThreadCallBack\r\n");
    }
}

int main()
{
    std::thread td(ThreadCallBack);

    for (int i = 0; i < 100; ++i)
    {
        std::lock_guard<std::mutex> lockGuard(s_mutex);
        // 以下两种写法不建议使用
        // std::lock_guard<std::mutex>&& lockGuard1(std::move(lockGuard));
        // std::lock_guard<std::mutex>* p = new std::lock_guard<std::mutex>(s_mutex);
        ColorPrintf(Green, "main\r\n");
    }

    td.join();
    getchar();
    return 1;
}

2、std::unique_lock

和lock_guard类似，也是提供在析构时unlock。但他的功能比lock_guard强大，主要是多了几个功能。

除了std::mutex和std::recursive_mutex，std 还提供了std::timed_mutex和std::recursive_timed_mutex ,他们比普通mutex多了两个函数try_lock_for、try_lock_until。

其中try_lock_for函数意思是在一段时间内尝试获取所有权，而不是获取所有权一段时间

代码如下：


#include <thread>
#include <mutex>

/** 互斥量
*/
static std::recursive_timed_mutex s_mutex;

/** 不带参数的线程回调
*/
void ThreadCallBack()
{
    std::unique_lock<std::recursive_timed_mutex> lockGuard(s_mutex);

    // 获取所有权后不释放
    ::Sleep(99999999);
    ColorPrintf(Red, "ThreadCallBack\r\n");
}

int main()
{
    std::thread td(ThreadCallBack);

    {
        // 让线程先获取所有权
        ::Sleep(1000);
        std::unique_lock<std::recursive_timed_mutex> 
            lockGuard(s_mutex, std::defer_lock_t());

        // 如果ThreadCallBack中的sleep时间小于下面的5000，tryRes就为true，否重为false 
        // 证明了try_lock_for是在一段时间内尝试获取所有权，而不是获取所有权一段时间
        bool tryRes = lockGuard.try_lock_for(std::chrono::milliseconds(5000));
        ::Sleep(999999999);
    }

    td.join();
    getchar();
    return 1;
}

try_lock_until就是直到的语义，这里不在重复。

std::unique_lock比std::lock_guard强大的地方在于可以支持try_lock_for和try_lock_until。另外std::unique_lock是可以拷贝和复值构造的，但是最好还是别这要使用。

2、std::condition_variable

条件变量，一个生产者消费者模型。使用场景：某个线程等待其他线程准备（阻塞），另外线程准备好了就通知他（让他停止阻塞）。示例：


#include <thread>
#include <condition_variable>

/** 互斥量
*/
static std::mutex s_mutex;
static std::condition_variable s_con;

/** 不带参数的线程回调
*/
void ThreadCallBack()
{
    // 不会死锁，考虑：
    // 1、m_mutex.unlock();
    // 2、wait()
    // 3、m_mutex.lock();
    // s_con.wait(lck) 相当于将1、2两步放到一个cpu周期内
    std::unique_lock<std::mutex> lck(s_mutex);
    s_con.wait(lck);
    ColorPrintf(Red, "ThreadCallBack\r\n");
}

int main()
{
    std::thread td(ThreadCallBack);

    {
        // 让线程先获取所有权
        ::Sleep(1000);
        ColorPrintf(Green, "main\r\n");
        s_con.notify_all();
    }

    td.join();
    getchar();
    return 1;
}

结果如下：

即便main函数sleep了一秒，但依然是绿色先输出。

但是

std::unique_lock<std::mutex> lck(s_mutex);
s_con.wait(lck);

 比较奇怪，先lock再wait不就死锁了？

但是事实上不会死锁，考虑：
1、s_mutex.unlock();
2、wait() // 语义上的wait区别于s_con.wait(lck); 
3、s_mutex.lock();
s_con.wait(lck);相当于将1、2两步放到一个cpu周期内，具体如何放到一个周期内可以搜索无锁编程（CAS）

注意：如果先notify然后在wait的话依然会等待。

3、std::atomic

使用简单，但是原理复杂，感兴趣可以搜索无锁编程（CAS）。

最后

本篇介绍了如何线程同步，下篇会介绍死锁。

 

我叫侯万楼
关注
  • 1
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++线程管理同步类库
02-25
线程是我们编程中使用非常频繁的操作。线程本身难度不大，但实际使用中往往棘手，特别是在大量使用中，会遇到线程间同步、关闭释放、跨线程通讯、启动大量线程时耗时等问题。同时多处使用还会产生大量的冗余代码。下面实现一个静态库来解决线程使用中遇到的问题。
C++ 线程（串行 并行 同步 异步）详解
12-31
C++  线程（串行 并行 同步 异步）详解 看了很多关于这类的文章，一直没有总结。不总结的话就会一直糊里糊涂，以下描述都是自己理解的非官方语言，不一定严谨，可当作参考。 首先，进程可理解成一个可执行文件的执行过程。在ios app上的话我们可以理解为我们的app的.ipa文件执行过程也即app运行过程。杀掉app进程就杀掉了这个app在系统里运行所占的内存。 线程：线程是进程的最小单位。一个进程里至少有一个主线程。就是那个main thread。非常简单的app可能只需要一个主线程即UI线程。当然大部分还是会有一些子线程的，比如如果你用了AFNetWorking，你的请求都是开辟了子线程。
[C++]线程同步的几种方式
最新发布
FL1768317420的博客
03-03 1168
进程有自己的独立地址空间，因此进程之间重点关注通信，通信方式包括：管道Pipe、命名管道FIFO、消息队列MessageQueue、共享存储SharedMemory、信号量Semaphore、套接字Socket和信号Signal。线程除了线程栈外其他数据都是共享的，如果同时读写数据可能造成数据不一致甚至程序崩溃的后果，因此线程之间重点关注同步。互斥锁（又名互斥量）强调的是资源之间的访问互斥：每个线程在对共享资源操作前都会尝试先加锁，加锁成功才能操作，操作结束之后解锁。
线程数据共享-解锁与上锁工具探析
weixin_43400299的博客
08-26 442
C++中的上锁与解锁工具
c语言 lock用法,c – 如何在try_lock_for中使用lock_guard
weixin_32236881的博客
05-23 967
我可以使用boost :: lock_guard来获取对boost :: mutex对象的锁定,这个机制将确定一旦boost :: lock_guard超出范围,锁将被释放：{boost::lock_guard lock(a_mutex);// Do the work}在这种情况下,无论代码块是否被异常退出,都将释放a_mutex.另一方面,boost :: timed_mutex也支持方法try...
C++实现线程同步的几种方式
m0_74282605的博客
10-14 747
在C++中，通过构造std::mutex的实例来创建互斥元，可通过调用其成员函数lock()和unlock()来实现加锁和解锁，然后这是不推荐的做法，因为这要求程序员在离开函数的每条代码路径上都调用unlock()，包括由于异常所导致的在内。3.LeaveCriticalSection(LPCRITICAL_SECTION lpCriticalSection)，该函数的作用是使调用该函数的线程离开临界区并释放对该临界区的所有权，以便让其他线程也获得访问该共享资源的机会。该函数将在用户指定的事件对象上等待。
互斥锁 try_lock 自旋锁 读写锁 原子操作 共享内存
饭真好吃的博客
08-05 1157
锁
C++线程锁之互斥锁（mutex）
qq_35973549的博客
04-29 1360
今天面试提到了C++线程锁，因此在这里整理下相关知识点，便于复习。 线程之间的锁主要有互斥锁、条件锁、自旋锁、读写锁、递归锁（一般锁功能越强大，性能越低）。 这篇博客主要整理下互斥锁的一点基本知识。 mutex又称互斥量，用于提供对共享变量的互斥访问。 头文件：#include<mutex> 与std::thread一样，mutex相关类不支持拷贝构造、赋值。同时mut...
C++(11)：批量上锁try_lock及lock
风静如云的博客
05-04 2560
C++11标准库提供了批量上锁函数： std::try_lock: template <class Mutex1, class Mutex2, class... Mutexes> int try_lock (Mutex1& a, Mutex2& b, Mutexes&... cde); try_lock尝试对其参数列表内的mutex对象依次执行其成员函数try_lock 如果某个mutex对象的try_lock失败（返回false），那么已经被加锁的mutex对象
【C++多线程编程】（八）之 详解trylock ( )
SensizliK
12-23 656
尝试获取互斥量的锁，如果成功获取，则执行一些对共享资源的操作，并在最后手动解锁。如果没有成功获取锁，程序输出失败消息。这种方式适用于需要在获取锁之前检查锁的状态的场景。，该函数用于尝试上锁，但如果锁已经被其他线程占用，则不会阻塞当前线程，而是会立即返回。这使得我们可以根据返回值来判断互斥量是否已经被其他线程锁住。如果当前线程成功获取了锁，它会返回。类型的互斥量提供了一个成员函数。
C++多线程同步
书山有路勤为径
03-22 4975
摘要：本文介绍了C++11中如何开启新线程，并详细讲解了线程的基础同步原语：mutex, lock_guard, unique_lock, condition variable和semaphore等。如何采用async, packaged_task和promise实现future同步机制？怎样处理spurious wakeup?本文以质数判定服务为例为大家分享C++多线程同步措施！ 1. C++线程和基础同步原语 Thread mutex, lock_guard, unique_lock con.
C++线程同步实例分析
12-31
本文实例分析了C++线程同步问题，分享给大家供大家参考。具体分析如下： 该实例设置全局变量g_bContinue，在主线程中设置全局变量g_bContinue，工作线程检测该全局变量，实现主线程控制工作线程的目的。 打印出的g_...
C++多线程编程——线程同步（保姆级-1.4W字）
qq_25218501的博客
08-25 933
线程同步是一种编程技术，它用于在多线程环境中确保多个线程能够正确、安全地共享和访问共享资源。线程同步的主要目的是防止数据竞争和不一致性，以及避免多个线程同时对同一数据进行修改或访问导致的问题。
C++11多线程（二） 互斥量(锁)——四种互斥量
AczQc的博客
06-26 764
文章目录C++11多线程（二） 四种锁的应用mutex（互斥量）lock(),unlock()封装应用timed_mutex(时间互斥锁)timed_mutex常用方法try_lock_for()：try_lock_until():recursive_mutex（递归锁）recursive_timed_mutex补充 C++11多线程（二） 四种锁的应用 mutex（互斥量） mutex，也就是最简单的互斥锁。使用lock(),unlock()函数来进行加锁解锁操作。 还记得在C++11多线程（一）中我提到
C++11多线程(四):lock详解
ceasadan的博客
01-04 2410
参考链接:http://www.cnblogs.com/haippy/p/3346477.html 目录 1.c++11 lock介绍 2.std::lock_guard 3.std::unique_lock 1.c++11 lock介绍 C++11 标准为我们提供了两种基本的锁类型，分别如下： std::lock_guard，与 Mutex RAII 相关，方便线程
c++多线程 四----（互斥与锁 ）
比卡丘不皮的博客
09-15 470
标准库支持互斥的形式包括互斥体（mutex）类和锁类。这些都可以实现同步。 互斥类： 与互斥类都定义在<mutex>中，所以使用的话，需要加载这个头文件 非定时的互斥体类： std::mutex; std::recursive_mutex; 都支持下面的方法： lock(): 调试线程将尝试获取锁，并且阻塞直到获得锁。这个方法会无限期的阻塞。如果希望设置线程阻塞的最长时间，应该使用定时的互斥体。 try_lock(): 调用线程将尝试获得锁，如果当前锁被其他线程持有，这个...
【C++】多线程同步
目标：MVP
02-21 6630
线程间的同步方法大体可以分为两类：用户模式和内核模式。内核模式就是指利用系统内核对象的单一性来进行同步，使用时需要切换内核态与用户态，而用户模式就是不需要切换到内核态，只在用户态完成操作。 用户模式下的方法有：原子操作（例如一个单一的全局变量）、临界区。特点是：同步速度特别快。 内核模式下的方法有：事件、信号量、互斥量。同步速度较慢，但适用性比较好。 **临界区：**通过对多线程的串行化来访问公共资源或一段代码、速度快，适合控制数据访问。 **互斥量：**为协调共同对一个共享资源的单独访问而设计的。 *
C++线程同步的方法
钟离默的个人博客
05-18 1672
线程同步 线程之间通信的两个基本问题是互斥和同步。 线程同步是指线程之间所具有的一种制约关系，一个线程的执行依赖另一个线程的消息，当它没有得到另一个线程的消息时应等待，直到消息到达时才被唤醒。 线程互斥是指对于共享的操作系统资源在各线程访问时的排它性。当有若干个线程都要使用某一共享资源时，任何时刻最多只允许一个线程去使用，其它要使用该资源的线程必须等待，直到占用资源者释放该资源。 线程互斥是一种特...
c++线程二
lichao201005的专栏
03-21 2012
接上篇！ 其实用mutex的lock()、unlock(), 当然更好用lock_guard()，这些基本能满足我们的应用需求，且容易理解。 一、unique_lock 相比lock_gaurd有一些更灵活的用法 主要体现在unique_lock的参数和成员函数上。如下一目了然，不再举例子。 unique_lock<mutex> uniqeLock(mu, std::adopt_lock);//同lock_guard, 指示不加锁，前提是mutex已经加锁 unique_lock&lt
c++实现线程同步
05-28
在 C++ 中，可以使用多种方式实现线程同步，以下是其中的几种： 1. 互斥锁（Mutex） 互斥锁是一种最常见的线程同步机制。它可以保证同时只有一个线程可以访问共享资源，其他线程需要等待该线程释放锁之后才能访问...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值