C++多线程入门：多线程通信与同步

字数统计: 1.4k字   |   阅读时长≈ 5分

线程的状态

线程拥有的状态：

  1. 初始化：准备创建线程。
  2. 就绪：等待线程执行。
  3. 运行：调用该线程，执行逻辑。
  4. 阻塞：该线程被挂起，等待重新唤醒，阻塞包括锁、事件、信号量阻塞，延迟等。
  5. 退出：结束线程并释放资源。

线程的竞争状态：

  • 竞争状态：包括读写状态的竞争
  • 临界区：读写数据的代码片段

为了保护临界区的状态，一般使用锁来控制。

使用锁

一般锁

一般可以使用锁来保证对临界区的控制：

1
2
3
4
5
6
7
8
9
10
11
12
#include <thread>
#include <mutex>

static mutex mtx;
void ThreadMutex()
{
    for(;;){
        mtx.lock();
        // 执行逻辑
        mtx.unlock();
    }
}

这是锁最普通的用法，但上述逻辑存在bug：当锁使用完成后释放锁，在for中跳转到下一个逻辑是相当快的，就可能导致unlock后还未来得及释放就再次上锁，导致下一个循环逻辑阻塞。
因此可以延后来确保锁被释放：

1
2
3
4
//...
mtx.unlock();
this_thread::sleep_for(1ms);
//...

超时锁

超时锁可以记录锁的获取情况，如果获取到锁则返回true，大致使用如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <thread>
#include <mutex>

timed_thread tmtx;
void ThreadTimedMutex()
{
    for(;;){
        if(!tmtx.try_lock_for(300ms)){
            // 进行日记记录

            // 获取锁会消耗资源，等待一段时间重新获取以节省资源
            this_thread::sleep_for(200ms);
            continue;
        }
        // 执行逻辑代码

        tmtx.unlock();
    }
}

递归锁

对于一些逻辑的处理，我们希望可以处理多次，因而需要多次加锁，对于一般的锁这是难以做到的，所以可以使用递归锁来实现该功能。
递归锁：通过增加计数来加锁，增加几次锁就到释放几次锁。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <thread>
#include <mutex>
recursive_mutex rmtx;
void ThreadRecMutex()
{
    if(){
        //返回条件
    }
    rmtx.lock();

    // 执行逻辑

    rmtx.unlock();
}

共享锁

一块数据可能不止一个线程在访问，可以多个线程同时读取，这是没有问题的；但若有线程此时对数据进行写操作自然是希望其它线程先暂停访问。
为了实现上述功能，可以使用共享锁来实现，在c++14中共享锁为shared_timed_mutex，而在C++17中为shared_mutex，这里使用C++14实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#include <iostream>
#include <thread>
#include <shared_mutex>
shared_timed_mutex sharedmutex;
void ReadThread()
{
    for(;;){
        sharedmutex.lock_shared();
        
        // 执行逻辑，循环读入

        sharedmutex.unlock_shared();

    }
}

void WriteThread()
{
    for(;;){
        smuts.lock_shared();
        // 确保锁资源被释放
        smuts.unlock_shared();

        // 互斥锁 lock后其它线程的读取数据操作将被阻塞
        smuts.lock();
        // 写入数据
        smuts.unlock();
        // 释放锁
    }
}

管理锁

在一段逻辑中可能会由于抛出异常或return语句等提前结束逻辑导致锁没有被unlock，所以为了防止死锁就需要对锁进行一些手动或自动管理。基于RAII这一特性。

手动管理

我们可以使用局部对象离开作用域时自动调用析构函数的特性来实现手动管理。
所以选择对锁进行封装：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
class Mutex
{
public:
    Mutex(mutex& Mtx):mtx(Mtx)
    {
        printf("Lock\n");
        mtx.lock();
    }

    ~Mutex()
    {
        printf("Unlock");
        mux.unlock();
    }

private:
    mutex& mtx;
};

static mutex m;
void TestMutex()
{
    Mutex mt(m);
    // 执行逻辑，不需要管理锁的释放
}

这是我们自己实现的手动管理锁，在C++中也为我们提供了现成的方法。

使用C++提供的管理方式

C++为我们提供了几种锁来管理：

lock_guard

lock_guard提供了两种构造函数，只要传入对象包含lock和unlock函数
该锁功能包括：

  1. 自动加锁，只要包装对象拥有lock和unlock函数
  2. 不支持对象所有权转移，即没有拷贝构造和赋值运算
  3. 可以使用adopt_lock不上锁
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
static mutex mtx;
void TestGuard()
{   
    mtx.lock();
    {
        // 起始时已经锁住
        // 增加adpot_lock参数确保Lock不抛出异常，Lock提供构造函数中该构造函数不进行上锁
        lock_guard<mutex> Lock(mtx,adopt_lock);
        // {}内容结束后释放锁
    }
    for(;;){
        lock_guard<mutex> Lock(mtx); // 期望在一个区域内实现锁
        // 执行逻辑
    }
}

unique_lock

unique_lock包括：

  1. 支持临时释放锁
  2. 使用adopt_lock，即用有锁则不加锁
  3. 支持defer_lock，延后拥有锁
  4. 支持tryto_lock，尝试获得锁所有权而不阻塞，获取失败不会释放，通过owns_lock判断是否获取到锁
  5. 可以转换所有权
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
staic mutex mtx;
void test()
{
    {
        unique_lock<mutex> Lock(mtx);
        Lock.unlock();
        // 支持临时释放锁
        Lock.lock();
    }

    {
        mtx.lock();
        unique_lock<mutex> Lock(mtx,adopt_lock);
    }

    {
        // 延迟拥有锁
        unique_lock<mutex> Lock(mtx,defer_lock);
        //...
        //主动加锁
        Lock.lock();
    }

    {
        // 尝试加锁，不阻塞，失败不拥有锁
        unique_lock<mutex> Lock(mtx,try_to_lock);
        if(Lock.owns_lock()){
            // 用有所则为true
            printf("owns_lock"); 
        }
    }
}

shared_lock

从C++14开始支持。
shared_lock支持移动，即可以通过赋值一脚锁所有权。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
static shared_time_mutex smtx;
void test()
{
    {
        //读取锁--->共享锁
        //调用共享锁
        shared_lock<shared_timed_mutex> Lock(smtx);
    }

    {
        //写入所--->互斥锁
        //移交拥有权
        unique_lock<shared_time_mutex> Lock(smtx);
    }
}

scoped_lock

这是C++17中新增的lock，用于两个线程之间的锁 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
static mutex mtx1;
static mutex mtx2;
void test1()
{
    mtx1.lock();
    mtx2.lock();
    this_thread::sleep(200ms);
    mtx1.unlock();
    mtx2.unlock();
}

void test2()
{
    mtx1.lock();
    mtx2.lock();
    this_thread::sleep(300ms);
    mtx1.unlock();
    mtx2.unlock();
}

如果两个线程同时运行可能会由于时间差导致死锁，一般可以使用lock同时锁：

1
lock(mtx1,mtx2);

使用C++17提供的解决方案：

1
scope_lock Lock(mtx1,mtx2);

这是一个多参数构造函数，会为提供的锁同时加锁，离开作用域时自动释放

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true


个人简介:
大学生一枚，想要从事游戏开发,
希望能做出自己的游戏

主要涉及技术：
UE4、Unity2D、C++