C++线程池同步方法

最新推荐文章于 2024-04-22 15:24:17 发布
最新推荐文章于 2024-04-22 15:24:17 发布
阅读量775 收藏 1
点赞数
分类专栏： vc++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_21743659/article/details/108198783
版权

  线程同步是指同一进程中的多个线程互相协调工作从而达到一致性。之所以需要线程同步，是因为多个线程同时对一个数据对象进行修改操作时，可能会对数据造成破坏，下面是多个线程同时修改同一数据造成破坏的例子：

复制代码

 1 #include <thread>
 2 #include <iostream>
 3 
 4 void Fun_1(unsigned int &counter);
 5 void Fun_2(unsigned int &counter);
 6 
 7 int main()
 8 {
 9     unsigned int counter = 0;
10     std::thread thrd_1(Fun_1, counter);
11     std::thread thrd_2(Fun_2, counter);
12     thrd_1.join();
13     thrd_2.join();
14     system("pause");
15     return 0;
16 }
17 
18 void Fun_1(unsigned int &counter)
19 {
20     while (true)
21     {
22         ++counter;
23         if (counter < 1000)
24         {
25             std::cout << "Function 1 counting " << counter << "...\n";
26         }
27         else
28         {
29             break;
30         }
31     }
32 }
33 
34 void Fun_2(unsigned int &counter)
35 {
36     while (true)
37     {
38         ++counter;
39         if (counter < 1000)
40         {
41             std::cout << "Function 2 counting " << counter << "...\n";
42         }
43         else
44         {
45             break;
46         }
47     }
48 }

复制代码

      运行结果如图所示：

      显然输出的结果存在问题，变量并没有按顺序递增，所以线程同步是很重要的。在这里记录三种线程同步的方式：

　　①使用C++标准库的thread、mutex头文件：

复制代码

 1 #include <thread>
 2 #include <mutex>
 3 #include <iostream>
 4 
 5 void Fun_1();
 6 void Fun_2();
 7 
 8 unsigned int counter = 0;
 9 std::mutex mtx;
10 
11 int main()
12 {
13     std::thread thrd_1(Fun_1);
14     std::thread thrd_2(Fun_2);
15     thrd_1.join();
16     thrd_2.join();
17     system("pause");
18     return 0;
19 }
20 
21 void Fun_1()
22 {
23     while (true)
24     {
25         std::lock_guard<std::mutex> mtx_locker(mtx);
26         ++counter;
27         if (counter < 1000)
28         {
29             std::cout << "Function 1 counting " << counter << "...\n";
30         }
31         else
32         {
33             break;
34         }
35     }
36 }
37 
38 void Fun_2()
39 {
40     while (true)
41     {
42         std::lock_guard<std::mutex> mtx_locker(mtx);
43         ++counter;
44         if (counter < 1000)
45         {
46             std::cout << "Function 2 counting " << counter << "...\n";
47         }
48         else
49         {
50             break;
51         }
52     }
53 }

复制代码

　　这段代码与前面一段代码唯一的区别就是在两个线程关联的函数中加了一句 std::lock_guard<std::mutex> mtx_locker(mtx); 在C++中，通过构造std::mutex的实例来创建互斥元，可通过调用其成员函数lock()和unlock()来实现加锁和解锁，然后这是不推荐的做法，因为这要求程序员在离开函数的每条代码路径上都调用unlock()，包括由于异常所导致的在内。作为替代，标准库提供了std::lock_guard类模板，实现了互斥元的RAII惯用语法（资源获取即初始化）。该对象在构造时锁定所给的互斥元，析构时解锁该互斥元，从而保证被锁定的互斥元始终被正确解锁。代码运行结果如下图所示，可见得到了正确的结果。

 

 

　　②使用windows API的临界区对象：

复制代码

 1 //header.h
 2 #ifndef CRTC_SEC_H
 3 #define CRTC_SEC_H
 4 
 5 #include "windows.h"
 6 
 7 class RAII_CrtcSec
 8 {
 9 private:
10     CRITICAL_SECTION crtc_sec;
11 public:
12     RAII_CrtcSec() { ::InitializeCriticalSection(&crtc_sec); }
13     ~RAII_CrtcSec() { ::DeleteCriticalSection(&crtc_sec); }
14     RAII_CrtcSec(const RAII_CrtcSec &) = delete;
15     RAII_CrtcSec & operator=(const RAII_CrtcSec &) = delete;
16     //
17     void Lock() { ::EnterCriticalSection(&crtc_sec); }
18     void Unlock() { ::LeaveCriticalSection(&crtc_sec); }
19 };
20 
21 #endif

复制代码

复制代码

 1 //main.cpp
 2 #include <windows.h>
 3 #include <iostream>
 4 #include "header.h"
 5 
 6 DWORD WINAPI Fun_1(LPVOID p);
 7 DWORD WINAPI Fun_2(LPVOID p);
 8 
 9 unsigned int counter = 0;
10 RAII_CrtcSec cs;
11 
12 int main()
13 {
14     HANDLE h1, h2;
15     h1 = CreateThread(nullptr, 0, Fun_1, nullptr, 0, 0);
16     std::cout << "Thread 1 started...\n";
17     h2 = CreateThread(nullptr, 0, Fun_2, nullptr, 0, 0);
18     std::cout << "Thread 2 started...\n";
19     CloseHandle(h1);
20     CloseHandle(h2);
21     //
22     system("pause");
23     return 0;
24 }
25 
26 DWORD WINAPI Fun_1(LPVOID p)
27 {
28     while (true)
29     {
30         cs.Lock();
31         ++counter;
32         if (counter < 1000)
33         {
34             std::cout << "Thread 1 counting " << counter << "...\n";
35             cs.Unlock();
36         }
37         else
38         {
39             cs.Unlock();
40             break;
41         }
42     }
43     return 0;
44 }
45 
46 DWORD WINAPI Fun_2(LPVOID p)
47 {
48     while (true)
49     {
50         cs.Lock();
51         ++counter;
52         if (counter < 1000)
53         {
54             std::cout << "Thread 2 counting " << counter << "...\n";
55             cs.Unlock();
56         }
57         else
58         {
59             cs.Unlock();
60             break;
61         }
62     }
63     return 0;
64 }

复制代码

　　上面的代码使用了windows提供的API中的临界区对象来实现线程同步。临界区是指一个访问共享资源的代码段，临界区对象则是指当用户使用某个线程访问共享资源时，必须使代码段独占该资源，不允许其他线程访问该资源。在该线程访问完资源后，其他线程才能对资源进行访问。Windows API提供了临界区对象的结构体CRITICAL_SECTION，对该对象的使用可总结为如下几步：

　　1.InitializeCriticalSection(LPCRITICAL_SECTION lpCriticalSection)，该函数的作用是初始化临界区，唯一的参数是指向结构体CRITICAL_SECTION的指针变量。

　　2.EnterCriticalSection(LPCRITICAL_SECTION lpCriticalSection)，该函数的作用是使调用该函数的线程进入已经初始化的临界区，并拥有该临界区的所有权。这是一个阻塞函数，如果线程获得临界区的所有权成功，则该函数将返回，调用线程继续执行，否则该函数将一直等待，这样会造成该函数的调用线程也一直等待。如果不想让调用线程等待（非阻塞），则应该使用TryEnterCriticalSection(LPCRITICAL_SECTION lpCriticalSection)。

　　3.LeaveCriticalSection(LPCRITICAL_SECTION lpCriticalSection)，该函数的作用是使调用该函数的线程离开临界区并释放对该临界区的所有权，以便让其他线程也获得访问该共享资源的机会。一定要在程序不适用临界区时调用该函数释放临界区所有权，否则程序将一直等待造成程序假死。

　　4.DeleteCriticalSection(LPCRITICAL_SECTION lpCriticalSection)，该函数的作用是删除程序中已经被初始化的临界区。如果函数调用成功，则程序会将内存中的临界区删除，防止出现内存错误。

　　该段代码的运行结果如下图所示：

 

 

　　③使用Windows API的事件对象：

复制代码

 1 //main.cpp
 2 #include <windows.h>
 3 #include <iostream>
 4 
 5 DWORD WINAPI Fun_1(LPVOID p);
 6 DWORD WINAPI Fun_2(LPVOID p);
 7 
 8 HANDLE h_event;
 9 unsigned int counter = 0;
10 
11 int main()
12 {
13     h_event = CreateEvent(nullptr, true, false, nullptr);
14     SetEvent(h_event);
15     HANDLE h1 = CreateThread(nullptr, 0, Fun_1, nullptr, 0, nullptr);
16     std::cout << "Thread 1 started...\n";
17     HANDLE h2 = CreateThread(nullptr, 0, Fun_2, nullptr, 0, nullptr);
18     std::cout << "Thread 2 started...\n";
19     CloseHandle(h1);
20     CloseHandle(h2);
21     //
22     system("pause");
23     return 0;
24 }
25 
26 DWORD WINAPI Fun_1(LPVOID p)
27 {
28     while (true)
29     {
30         WaitForSingleObject(h_event, INFINITE);
31         ResetEvent(h_event);
32         if (counter < 1000)
33         {
34             ++counter;
35             std::cout << "Thread 1 counting " << counter << "...\n";
36             SetEvent(h_event);
37         }
38         else
39         {
40             SetEvent(h_event);
41             break;
42         }
43     }
44     return 0;
45 }
46 
47 DWORD WINAPI Fun_2(LPVOID p)
48 {
49     while (true)
50     {
51         WaitForSingleObject(h_event, INFINITE);
52         ResetEvent(h_event);
53         if (counter < 1000)
54         {
55             ++counter;
56             std::cout << "Thread 2 counting " << counter << "...\n";
57             SetEvent(h_event);
58         }
59         else
60         {
61             SetEvent(h_event);
62             break;
63         }
64     }
65     return 0;
66 }

复制代码

　　事件对象是一种内核对象，用户在程序中使用内核对象的有无信号状态来实现线程的同步。使用事件对象的步骤可概括如下：

　　1.创建事件对象，函数原型为：

复制代码

1 HANDLE WINAPI CreateEvent(
2   _In_opt_ LPSECURITY_ATTRIBUTES lpEventAttributes,
3   _In_     BOOL                  bManualReset,
4   _In_     BOOL                  bInitialState,
5   _In_opt_ LPCTSTR               lpName
6 );

复制代码

　　如果该函数调用成功，则返回新创建的事件对象，否则返回NULL。函数参数的含义如下：

　　-lpEventAttributes：表示创建的事件对象的安全属性，若设为NULL则表示该程序使用的是默认安全属性。

　　-bManualReset：表示所创建的事件对象是人工重置还是自动重置。若设为true，则表示使用人工重置，在调用线程获得事件对象所有权后用户要显式地调用ResetEvent()将事件对象设置为无信号状态。

　　-bInitialState：表示事件对象的初始状态。如果为true，则表示该事件对象初始时为有信号状态，则线程可以使用事件对象。

　　-lpName：表示事件对象的名称，若为NULL，则表示创建的是匿名事件对象。

　　2.若事件对象初始状态设置为无信号，则需调用SetEvent(HANDLE hEvent)将其设置为有信号状态。ResetEvent(HANDLE hEvent)则用于将事件对象设置为无信号状态。

　　3.线程通过调用WaitForSingleObject()主动请求事件对象，该函数原型如下：

1 DWORD WINAPI WaitForSingleObject(
2   _In_ HANDLE hHandle,
3   _In_ DWORD  dwMilliseconds
4 );

　　该函数将在用户指定的事件对象上等待。如果事件对象处于有信号状态，函数将返回。否则函数将一直等待，直到用户所指定的事件到达。

 　　该代码的运行结果如下图所示：

　　

 

　　④使用Windows API的互斥对象：

复制代码

 1 //main.cpp
 2 #include <windows.h>
 3 #include <iostream>
 4 
 5 DWORD WINAPI Fun_1(LPVOID p);
 6 DWORD WINAPI Fun_2(LPVOID p);
 7 
 8 HANDLE h_mutex;
 9 unsigned int counter = 0;
10 
11 int main()
12 {
13     h_mutex = CreateMutex(nullptr, false, nullptr);
14     HANDLE h1 = CreateThread(nullptr, 0, Fun_1, nullptr, 0, nullptr);
15     std::cout << "Thread 1 started...\n";
16     HANDLE h2 = CreateThread(nullptr, 0, Fun_2, nullptr, 0, nullptr);
17     std::cout << "Thread 2 started...\n";
18     CloseHandle(h1);
19     CloseHandle(h2);
20     //
21     //CloseHandle(h_mutex);
22     system("pause");
23     return 0;
24 }
25 
26 DWORD WINAPI Fun_1(LPVOID p)
27 {
28     while (true)
29     {
30         WaitForSingleObject(h_mutex, INFINITE);
31         if (counter < 1000)
32         {
33             ++counter;
34             std::cout << "Thread 1 counting " << counter << "...\n";
35             ReleaseMutex(h_mutex);
36         }
37         else
38         {
39             ReleaseMutex(h_mutex);
40             break;
41         }
42     }
43     return 0;
44 }
45 
46 DWORD WINAPI Fun_2(LPVOID p)
47 {
48     while (true)
49     {
50         WaitForSingleObject(h_mutex, INFINITE);
51         if (counter < 1000)
52         {
53             ++counter;
54             std::cout << "Thread 2 counting " << counter << "...\n";
55             ReleaseMutex(h_mutex);
56         }
57         else
58         {
59             ReleaseMutex(h_mutex);
60             break;
61         }
62     }
63     return 0;
64 }

复制代码

　　互斥对象的使用方法和c++标准库的mutex类似，互斥对象使用完后应记得释放。

鱼儿-1226
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
3种多线程实现同步方法
04-03
很不错的源码，3种多线程实现同步方法
C++线程同步的几种方式
DK233333的博客
05-28 3635
1.临界区，通过对多线程的串行化来访问公共资源或一段代码，速度快，适合控制数据访问。确保在某个时刻只有一个线程能访问数据。此时其他线程如想访问数据则会被挂起，直到当前线程离开临界区。临界区被释放后，其他线程继续抢占。 2.互斥量，和临界区类似，可以保证同一时刻只有一个线程访问数据。类似java中的对象锁。成功获取互斥量的线程可以访问数据，其他线程将被挂起，直到当前线程释放互斥量。互斥量比临界区复...
C++多线程同步
书山有路勤为径
03-22 4978
摘要：本文介绍了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++]线程同步的几种方式
FL1768317420的博客
03-03 1174
进程有自己的独立地址空间，因此进程之间重点关注通信，通信方式包括：管道Pipe、命名管道FIFO、消息队列MessageQueue、共享存储SharedMemory、信号量Semaphore、套接字Socket和信号Signal。线程除了线程栈外其他数据都是共享的，如果同时读写数据可能造成数据不一致甚至程序崩溃的后果，因此线程之间重点关注同步。互斥锁（又名互斥量）强调的是资源之间的访问互斥：每个线程在对共享资源操作前都会尝试先加锁，加锁成功才能操作，操作结束之后解锁。
C++中四种进程或线程同步互斥的控制方法
记事本
01-21 9632
现在流行的进程线程同步互斥的控制机制，其实是由最原始最基本的4种方法实现的。由这4种方法组合优化就有了.Net和Java下灵活多变的，编程简便的线程进程控制手段。 　　这4种方法具体定义如下 在《操作系统教程》ISBN 7-5053-6193-7 一书中能够找到更加周详的解释 　　1临界区:通过对多线程的串行化来访问公共资源或一段代码，速度快，适合控制数据访问。 　　2互斥量:为协调一起对一个
【C++】多线程同步
目标：MVP
02-21 6633
线程间的同步方法大体可以分为两类：用户模式和内核模式。内核模式就是指利用系统内核对象的单一性来进行同步，使用时需要切换内核态与用户态，而用户模式就是不需要切换到内核态，只在用户态完成操作。 用户模式下的方法有：原子操作（例如一个单一的全局变量）、临界区。特点是：同步速度特别快。 内核模式下的方法有：事件、信号量、互斥量。同步速度较慢，但适用性比较好。 **临界区：**通过对多线程的串行化来访问公共资源或一段代码、速度快，适合控制数据访问。 **互斥量：**为协调共同对一个共享资源的单独访问而设计的。 *
C++线程同步的方法
钟离默的个人博客
05-18 1674
线程同步 线程之间通信的两个基本问题是互斥和同步。 线程同步是指线程之间所具有的一种制约关系，一个线程的执行依赖另一个线程的消息，当它没有得到另一个线程的消息时应等待，直到消息到达时才被唤醒。 线程互斥是指对于共享的操作系统资源在各线程访问时的排它性。当有若干个线程都要使用某一共享资源时，任何时刻最多只允许一个线程去使用，其它要使用该资源的线程必须等待，直到占用资源者释放该资源。 线程互斥是一种特...
多线程编程 ----- 四种同步方法
qq_40140790的博客
05-02 1385
多线程，就是在一个进程里除主线程外创建其他的线程为进程工作，为什么要使用多线程？因为使用多线程在多数情况下都能提升运行速度。多线程主要的应用场景有 避免阻塞（异步调用） 比如你用一般模型的socket通讯，没收到信息前都会堵塞等待，这是你创建多线程等待自己去做其他的。 避免CPU空转 以http server为例，如果只用单线程响应HTTP请求，即处理完一条请求，再处理下一条请求的话，...
C++实现线程同步的几种方式
m0_74282605的博客
10-14 750
在C++中，通过构造std::mutex的实例来创建互斥元，可通过调用其成员函数lock()和unlock()来实现加锁和解锁，然后这是不推荐的做法，因为这要求程序员在离开函数的每条代码路径上都调用unlock()，包括由于异常所导致的在内。3.LeaveCriticalSection(LPCRITICAL_SECTION lpCriticalSection)，该函数的作用是使调用该函数的线程离开临界区并释放对该临界区的所有权，以便让其他线程也获得访问该共享资源的机会。该函数将在用户指定的事件对象上等待。
C++ 线程同步
SJLin
08-17 631
一. 实现线程同步的方式 1. 临界区 临界区（Critical Section）是一段独占对某些共享资源访问的代码，在任意时刻只允许一个线程对共享资源进行访问。如果有多个线程试图同时访问临界区，那么在有一个线程进入后其他所有试图访问此临界区的线程将被挂起，并一直持续到进入临界区的线程离开。临界区在被释放后，其他线程可以继续抢占，并以此达到用原子方式操作共享资源的目的。 2. 事件（CEve...
C++之线程同步
u010378559的博客
07-07 390
线程同步总结
Linux c++ 线程池的实现
03-06
Linux下的c++的线程池实现，包括线程间的同步
LINUX C++ 线程池 框架
11-16
在计算机中发现的 拿出来分享 通用线程池框架由五个重要部分组成CThreadManage，CThreadPool，CThread，CJob，CWorkerThread，除此之外框架中还包括线程同步使用的类CThreadMutex和CCondition。
Linux C++ 服务器之线程池 C++11
11-09
基于Linux平台，C++开发，socket服务器之线程池，使用thread，同步利用mutex和condition_variable实现
C++Helper–使用C++11实现半同步半异步线程池
01-06
本文使用C++11的线程、互斥量和条件变量，实现了一个轻巧的线程池，可用于大量并发任务的场景，以避免频繁的线程创建和销毁，节约系统资源。 　本文对处理任务的接口，也进行了包装，可接受：函数对象、成员函数、...
基于WindowsAPI多线程操作管理的C++类封装
05-17
将WindowsAPI关于线程的操作封装为C++类，供Windows平台下C++相关多线程开发使用。
【C】 初识C语言
努力学习C/C++
04-21 786
从本篇开始，带你从不会C语言到精通C语言。这篇是让大家对C语言有个初步的了解。下面的内容会拆分不同篇幅单独进行详细讲叙。数据类型变量、常量字符串转义字符注释选择语句循环语句函数数组操作符常见关键字define定义常量和宏指针结构体1.什么是C语言？C语言是一门面向过程的计算机编程语言，与C++、C#、Java等面向对象编程语言有所不同。C语言的设计目标是提供一种能以简易的方式编译、处理低级存储器、仅产生少量的机器码以及不需要任何运行环境支持便能运行的编程语言。
C++ WebServer的细节理解
最新发布
我的博客
04-22 630
在非阻塞模式下，如果 I/O 操作不能立即完成（例如，因为没有数据可读 或 写缓冲区满），系统不会让调用进程阻塞等待，而是立即返回一个错误（通常为 EAGAIN 或 EWOULDBLOCK）。先查询文件描述符 fd 当前的标志，然后将 O_NONBLOCK 标志加入其中，并通过 F_SETFL 来更新文件描述符，最终实现将该文件描述符切换为非阻塞模式。这意味着，如果没有待处理的连接请求（即没有客户端尝试连接到服务器），accept() 会一直阻塞，直到有新的连接请求到达或发生其他特定条件（如超时）为止。
c++ 线程池 条件变量
09-29
c线程池中条件变量的作用是实现多个线程之间的同步操作。当条件不满足时，相关线程会被阻塞，直到某种条件成立，这些线程才会被唤醒。条件变量通常与互斥锁一起使用，互斥锁用于保护共享资源，而条件变量用于在某个...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值