【linux多线程】c++多线程的同步方式

已于 2022-06-18 21:54:33 修改
阅读量1.7k 收藏 14
点赞数 1
分类专栏： C/C++ 多线程编程 文章标签： c++ 开发语言 多线程编程 线程同步 linux多线程
于 2022-05-01 19:38:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baidu_35692628/article/details/124518306
版权

序言

1. 同步与互斥

  • 互斥和同步的区别：互斥是对共同资源的互斥访问，访问是乱序的，同步就是协调步调，按照一定顺序执行。同步一般已经实现了互斥，通过条件设置实现顺序访问。

  • C语言线程互斥和同步方式，在文章 C语言多线程同步方式一，C语言多线程同步方式二中已经做了介绍且有实例。

  • C语言线程同步的常见方式：

    1. 互斥锁
2. 条件变量
3. 读写锁
4. 自旋锁
5. 信号量
6. 关卡

    以下着重介绍几种常用的C++线程同步方式，包括互斥锁、条件变量、信号量

2. C++多线程同步方式

2.1 互斥锁

  • c++中互斥锁的使用比c复杂一些。c++可使用的互斥锁相关的类有

    1. std::mutex
2. std::lock
3. std::lock_guard
4. std::unique_lock
5. std::scoped_lock
2.1.1 使用实例：std::mutex
#include <thread>
#include <mutex>
#include <string>
#include <iostream>

std::mutex myMutex;
int num = 0;

void PrintNum(std::string str)
{
	while (num < 10)
	{
		myMutex.lock();		// 加锁
		std::cout << str << " num = " << num << std::endl;
		num++;
		myMutex.unlock();	// 解锁
	}
}

int main()
{
	std::thread threadOne(PrintNum, "thread one");
	std::thread threadTwo(PrintNum, "thread two");

	threadOne.join();
	threadTwo.join();
	return 0;
}

// 编译运行
g++ -o main main.cpp -pthread

这种需要手动解锁的都有忘记解锁的风险

2.1.2 使用实例：std::lock
  • std::lock通常不直接使用，而且使用条件也比较局限：“加锁动作不是分散的，而是要同时加锁”。可配合mutex/lock_guard/unique_lock一起使用
  • std::lock可以用来锁住两个或两个以上的互斥量或对象，且内部有免死锁算法避免死锁。若有任何一个不可用则把已锁定的释放掉然后阻塞等待，函数正常返回表示对象均已加锁
  • std::lock不会自动解锁，一般需要锁定互斥量或对象辅助进行解锁操作。互斥量的话就直接mutex.unlock，lock_guard/unique_lock对象则离开作用域自动解锁
  • std::lock与std::scoped_lock的区别见：使用实例 std::scoped_lock
  • 配合mutex使用
int num = 0;
std::mutex mutex1;
std::mutex mutex2;
void safe_increment()
{
	/*同时锁两个*/
	std::lock(mutex1, mutex2);
	
	for (int i = 0; i < 10000000; i++)
	{
	    ++num;
	}
	/*需要手动解锁*/
	std::cout << std::this_thread::get_id() << ": " << num << '\n';
	
	mutex1.unlock();
	mutex2.unlock();
}
  • 配合lock_guard使用
std::mutex mutex1;
std::mutex mutex2;

std::lock(mutex1, mutex2);	// 参数为互斥量，同时锁定两个互斥量

std::lock_guard lock1(mutex1, std::adopt_lock);
std::lock_guard lock2(mutex2, std::adopt_lock);

lock_guard使用adopt_lock参数表示这个互斥量已经被锁定了，不需要在构造函数中再加锁了

  • 配合unique_lock使用
std::mutex mutex1;
std::mutex mutex2;

std::unique_lock lock1(mutex1, std::defer_lock);
std::unique_lock lock2(mutex2, std::defer_lock);

std::lock(lock1, lock2);	// 参数为对象，同时锁定lock1和lock2两个对象

// 如果不需要两个同时锁定，也可以各自锁定
lock1.lock();
lock2.lock();

unique_lock中使用了defer_lock参数，表示加锁的动作可以留到后面进行，可能是加锁之前还有一些操作

  • std::lock是阻塞等待，std::try_lock是非阻塞等待，如果没有获取到锁，则不修改受保护对象，同时获取到锁返回-1可修改受保护对象。示例如下
std::mutex mutex1;
std::mutex mutex2;
void Function()
{
	while (true) {
		int result = std::try_lock(mutex1, mutex2);
		if (result == -1) {
			// do something
			mutex1.unlock();
			mutex2.unlock();
		}
	}
}
2.1.3 使用实例：std::lock_guard
  • 为避免mutex忘记unlock的出现，c11中引入了lock_guard，比较常用
  • std::lock_guard对象构造时加锁，对象析构时解锁。作用域内生效
  • std::lock_guard可与mutex互斥量配合使用，使用时不要手动unlock，防止析构函数再unlock时报异常。不可复制
  • 上锁不成功则阻塞等待
while (ros::ok()) {
	{
		std::mutex mutexVar,
		std::lock_guard<std::mutex> lockGuard(mutexVar);
		// do something
	}	// 离开作用域自动解锁
	...
}
2.1.4 使用实例：std::unique_lock
  • std::unique_lock对象构造时加锁，对象析构时解锁。作用域内生效
  • std::unique_lock可与mutex互斥量配合使用，可灵活加解锁
  • std::unique_lock可移动(可转移互斥量的所有权)不可复制
  • 上锁不成功则阻塞等待，使用try_to_lock则表示非阻塞
while (ros::ok()) {
	{
		std::mutex mutexVar,
		std::unique_lock<std::mutex> uniqueLock(mutexVar);
		if (!condition) {
			uniqueLock.unlock();	// 手动解锁
			continue;
		}
		// do something
	}	// 离开作用域自动解锁
	...
}
  • std::unique_lock还有try_to_lock、owns_lock等成员函数。调用try_to_lock上锁不成功不会阻塞在那里，此时可以去操作不受保护的数据
list<int> myList; // 受保护对象
mutex myMutex;

void Function()
{
    for (int num = 0; num < 10000; num++) {
        std::unique_lock<std::mutex> my_unique(myMutex, std::try_to_lock);
        if(my_unique.owns_lock()){
            cout<<"插入数据： "<<num<<endl;
            myList.push_back(num);
        }
        else{
            cout<<"没能拿到锁，只能干点别的事"<<endl;
        }
    }
}
2.1.5 使用实例：std::scoped_lock
  • c++17中才支持
  • std::scoped_lock内部封装了std::lock，同时析构函数调用了unlock。可在对象构造时加锁，对象析构时解锁，作用域内生效。同时内部也有免死锁算法避免死锁
  • std::scoped_lock可对一个或多个互斥量加解锁
  • std::scoped_lock不可复制也不可移动
std::mutex mutex1;
std::mutex mutex2;

std::scoped_lock scopedLock(mutex1, mutex2);

// 相当于
std::lock(mutex1, mutex2);	// 参数为互斥量，同时锁定两个互斥量
std::lock_guard lock1(mutex1, std::adopt_lock);
std::lock_guard lock2(mutex2, std::adopt_lock);

// 或者相当于
std::unique_lock lock1(mutex1, std::defer_lock);
std::unique_lock lock2(mutex2, std::defer_lock);
std::lock(lock1, lock2);	// 参数为对象，同时锁定lock1和lock2两个对象
2.2 条件变量
  • 条件变量通常结合unique_lock来使用，因为作用域内可能条件不满足需要解锁，lock_guard不支持这种操作
  • 常用的成员函数：wait()/notify_one()/notify_all()，详见 条件变量成员函数
  • 线程运行到条件后，如果条件不满足，阻塞在条件变量，wait函数内部会解锁，然后等待条件变量被其他线程激活，被激活后会尝试再次加锁，阻塞条件不成立再继续往下执行
  • 下面的例子是比较经典的生产者-消费者模型
#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <vector>

using namespace std;

std::mutex myMutex;		 // mutual exclusive lock
std::condition_variable condVar; // condition variable
std::vector<int> vec;		 // protected object

void Consumer()
{
    std::unique_lock<std::mutex> lock(myMutex);
    while (vec.empty()) {
        condVar.wait(lock);
    }
    std::cout << "consumer " << vec.size() << "\n";
}

void Producer()
{
    std::unique_lock<std::mutex> lock(myMutex);

    vec.push_back(1);
    
    condVar.notify_one();	// or condVar.notify_all()
    std::cout << "producer \n";
}

int main()
{
    std::thread newThread(Consumer);
    //newThread.detach();	// main-thread or sub-thread split
    Producer();
    newThread.join();
    return 0;
}
2.3 信号量
  • C++11中没有信号量，同样的效果可以通过互斥锁和条件变量来实现，且更安全
  • C语言中信号量又称信号灯，分为二元信号灯和多元信号灯，二元信号灯就是互斥锁，所以信号灯其实包含了互斥锁，只不过互斥锁用于资源互斥访问，信号量多用于线程同步。
  • C语言中信号量常用的成员函数: sem_init()/sem_wait()【P操作-】/sem_post()【V操作+】/sem_destroy()，详见 信号量的函数 和 C语言信号量实例
  • 此处通过互斥锁和条件变量来实现多元信号量，“吃水果问题”
#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>

using namespace std;

class Semaphore
{
public:
	Semaphore(int value = 1) : count(value) {}
    virtual ~Semaphore() = default;

    // P操作
    void P()
    {
        unique_lock<mutex> lock(myMutex);
		--count;
        if (count < 0)	//资源已经不足挂起等通知
            condVar.wait(lock);
    }

    // V操作
    void V()
    {
        unique_lock<mutex> lock(myMutex);
		++count;
        if (count <= 0)	// 有资源了，有线程挂起的话，通知一下
            condVar.notify_one();
    }

private:
    int count;
    mutex myMutex;
    condition_variable condVar;
};

// 初始化
Semaphore plate(1), apple(0), orange(0);

void Father()
{
    while (true)
    {
        plate.P();
       
       	cout << "往盘中放一个苹果" << endl;
       
       	apple.V();
    }
}

void Mother()
{
    while (true)
    {
        plate.P();

		cout << "往盘中放一个橘子" << endl;
	
		orange.V();
    }
}

void Son()
{
    while (true)
    {
        apple.P();

		cout << "儿子吃苹果" << endl;
	
		plate.V();
    }
}

void Daughter()
{
    while (true)
    {
        orange.P();

		cout << "女儿吃橘子" << endl;
	
		plate.V();
    }
}

int main()
{
    std::thread farther(Father), mother(Mother), son(Son), daughter(Daughter);
    farther.join();
    mother.join();
    son.join();
    daughter.join();
	return 0;
}
  • 上面的这个例子自己理一遍应该就懂为什么PV操作count要这么设计了

以下内容待补充总结。

2.4 读写锁
2.5 自旋锁
2.6 关卡

 

参考文章：
互斥锁的用法
std::lock的使用
std::scoped的使用
条件变量的使用
信号量的使用
c++信号量使用
c++线程同步方法

created by shuaixio, 2022.04.30

shuaixio
关注
  • 1
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux c++多线程串口编程demo
01-26
本示例"Linux c++多线程串口编程demo"聚焦于利用多线程技术实现串口通信，这是一种常见的硬件接口，用于设备之间的数据交换。下面我们将深入探讨这个demo涉及的知识点。 1. **多线程编程**：在C++中，我们可以使用`...
C++实现的Linux多线程聊天室
04-15
总结来说，C++实现的Linux多线程聊天室项目涉及了多线程编程、网络编程、同步与通信机制等多个核心知识点。通过这个项目，开发者不仅可以深入理解多线程在实际应用中的运用，还能锻炼到系统级编程的能力。
linux实现文本方式与图形方式的转换_Linux C++实现多线程同步的四种方式（超级详细）...
weixin_39721924的博客
11-24 139
背景问题：在特定的应用场景下，多线程不进行同步会造成什么问题？通过多线程模拟多窗口售票为例：#include #include#include#include#include#includeusing namespace std;int ticket_sum=20;void *sell_ticket(void *arg){for(int i=0; i<20; i++){if(ticket_s...
一文详解C++多线程
热门推荐
非晚非晚的博客
04-25 7万+
传统的C++（C++11之前）中并没有引入线程这个概念，在C++11出来之前，如果我们想要在C++中实现多线程，需要借助操作系统平台提供的API，比如Linux的，或者windows下的 。C++11提供了语言层面上的多线程，包含在头文件中。它解决了跨平台的问题，提供了管理线程、保护共享数据、线程间同步操作、原子操作等类。C++11 新标准中引入了5个头文件来支持多线程编程，如下图所示：
C++多线程同步总结
最新发布
yishuihanq的博客
06-07 558
C++ 多线程同步
【C++】多线程同步
目标：MVP
02-21 6878
线程间的同步方法大体可以分为两类：用户模式和内核模式。内核模式就是指利用系统内核对象的单一性来进行同步，使用时需要切换内核态与用户态，而用户模式就是不需要切换到内核态，只在用户态完成操作。 用户模式下的方法有：原子操作（例如一个单一的全局变量）、临界区。特点是：同步速度特别快。 内核模式下的方法有：事件、信号量、互斥量。同步速度较慢，但适用性比较好。 **临界区：**通过对多线程的串行化来访问公共资源或一段代码、速度快，适合控制数据访问。 **互斥量：**为协调共同对一个共享资源的单独访问而设计的。 *
C++、Linux多线程编程
weixin_45853844的博客
03-19 811
在Linux系统上，可以使用POSIX线程库（pthread库）进行多线程编程。pthread库提供了一系列线程相关的函数，可以用于创建和管理线程、同步和互斥等操作。
【Linux多线程服务端编程】| 【04】C++多线程系统编程精要
weixin_45926547的博客
09-27 907
从某个TCP连接A收到req，程序处理它需要一定时间，为了避免阻塞，程序需记住发来的req，在某个线程池中处理；但处理req时，客户端断开连接，而另一个客户端连接B；函数，则修改的变量必须为sig_atomic_t类型，从而优化了内存访问；【FD_CLOEXEC】：让exec时，进程自动关闭这个文件描述符；：每个磁盘配一个线程，把所有对此磁盘IO都挪到同一个线程；【O_NONBLOCK】：开启非阻塞，文件描述符默认为阻塞；的情况下，全局数据可能被其他线程修改，导致后续可能出现。同步IO：阻塞与非阻塞；
C++多线程
qq_61635026的博客
02-25 2047
在C++11之前没有多线程的概念，涉及到的与多线程的相关问题都是与操作系统有关的，例如Windows和Linux下都有各自的多线程接口，这使得代码的可移植性较差。，在指定时间点未到来之前线程如果没有获得锁则被阻塞住，如果在此期间其他线程释放了锁，则该线程可以获得对互斥量的锁，如果超时（即在指定时间内还是没有获得锁），则返回。thread类是防拷贝的，不允许拷贝构造以及赋值，但是可以移动构造和移动赋值，即将一个线程对象关联线程的状态转移给其他线程对象，转移期间不意向线程的执行。更为普遍的，我们可以使用。
linux下多线程C++运行时间统计
Hello World
06-29 8067
linux下多线程C++运行时间统计 CMakeLists.txt 下面所有的代码的CMakeLists.txt如下 cmake_minimum_required(VERSION 2.8) list(APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake/Modules) # else can not fin nullptr and...
Linux·C++多线程基础知识
m0_64560763的博客
11-08 1714
C++多线程基础知识
Linux C++多线程同步的四种方式
qq_41687938的博客
09-15 795
原文链接：Linux C++多线程同步的四种方式（非常详细）_Y先森0.0-CSDN博客 背景问题：在特定的应用场景下，多线程不进行同步会造成什么问题？ 通过多线程模拟多窗口售票为例： #include <iostream> #include<pthread.h> #include<stdio.h> #include<stdlib.h> #include<string.h> #include<unistd.h> using n
getcard-1.0.rar_linux 多线程
09-20
在这个场景中，我们讨论的是一个名为"getcard-1.0.rar_linux 多线程"的项目，它是一个专为Linux系统设计的多线程服务。这个服务的主要功能是监控特定目录下的文件变化，对这些文件进行相应的移动操作，并将它们上传...
Linux多线程服务端编程.rar
07-20
本文将深入探讨这个主题，并以“Linux多线程服务端编程：使用muduo C++网络库”这一资料为例，讲解如何利用多线程和muduo库来构建高效的服务端应用程序。 首先，多线程是现代计算机程序设计中常用的一种并发执行...
linux多线程服务端编程.rar
07-05
在Linux系统中，多线程...总之，Linux多线程服务端编程涉及的内容广泛，包括线程的创建、同步、通信以及服务端的架构设计、性能优化等多个方面。通过深入学习和实践，开发者可以构建出高效、稳定的多线程服务端应用。
pthread多线程求pi,linux多线程pthread,C,C++
09-10
在Linux系统中，`pthread`库是C和C++编程语言实现多线程的标准接口。本文将深入探讨标题和描述中提到的“pthread多线程求pi”这一主题，以及并行计算在解决复杂计算问题中的应用。 首先，我们要理解π（pi）的计算...
C++多线程多进程.doc
08-09
C++多线程多进程概述 C++多线程多进程是指在同一个程序中使用多个线程或进程来提高程序的并发度和响应时间。多线程多进程技术可以让程序在同一时间同时执行多条任务，从而提高程序的效率和响应速度。 进程是资源...
muduo C++库指导Linux多线程服务端实战
作者陈硕，拥有北京师范大学硕士学位，专长在于C++多线程网络编程和实时分布式系统架构，具有丰富的实战经验。 该书的核心内容围绕muduo C++网络库展开，这是一种在Linux用户态下编写高性能网络程序的成熟模式——...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值