多线程个人总结

最新推荐文章于 2021-08-04 11:55:12 发布

s_ky_

最新推荐文章于 2021-08-04 11:55:12 发布

阅读量330

点赞数

分类专栏： C/C++ # 多线程

本文链接：https://blog.csdn.net/dreamerLLL/article/details/87863447

版权

C/C++ 同时被 2 个专栏收录

4 篇文章 0 订阅

订阅专栏

多线程

1 篇文章 0 订阅

订阅专栏

线程创建

CreateThread (windows API)

使用此接口一般要求结束时调用CloseHandle关闭句柄.值得注意的是:
如果线程中使用了诸如strtok()等函数（_tiddata结构成员的注释标注了这些函数），C运行库会尝试读取该线程的tiddata，如果没有，则会分配一个。这样在使用CloseHandle()关闭句柄时，tiddata未被释放，造成内存泄露.使用CreatThread()创建，调用_endthreadex()关闭，又显得不匹配。所以还是建议使用_beginthreadex()。

_beginthreadex() (CRT)

_beginthreadex()是_beginthread()的改良版,比如新增设置优先权,创建时挂起等.接口如下:

unsignedlong _beginthreadex(
void *security,									//线程函数的安全描述符
unsigned stack_size,							// 堆栈大小，设置0为系统默认值
unsigned ( __stdcall *start_address )( void * ),//线程函数的起始地址
void*arglist, 									//传递给线程函数的参数，没有则为NULL
unsignedinitflag,								//初始状态，0为立即执行，CREATE_SUSPENDED为创建后挂起
unsigned*thrdaddr );							//指向一个32为的变量，存放线程标识符

_beginthreadex()在也是调用CreateThread()创建线程的，在调用CreateThread()之前会分配一个_tiddata结构用于新建线程使用

_beginthreadex()调用后发生的操作如下：
1、_beginthreadex新建一个tiddata，将线程函数和参数保存到里面，然后调用windows API的CreateThread()，其线程函数为_threadstartex()，参数为tiddata
2、_threadstartex()设置完tiddata后，调用_callthreadstartex()
3、_callthreadstartex()新建了一个SHE异常帧，然后执行_beginthreadex()参数中的线程函数，执行完毕后，调用_endthreadex()
4、_endthreadex()会获取tiddata，然后将其释放，最后调用ExitThread()退出线程.系统不能自动关闭线程句柄,需要手动关闭,相反_endthread会.这样其实也有个好处,那就是对WaitFor系列函数的调用就比较方便了.
注意:
1._beginthreadex()在正常运行结束后，会自动调用_endthreadex(),但不会关闭句柄,需要手动CloseHandle().
2._beginthreadex()的线程函数必须使用__stdcall调用方式，而且必须返回一个unsigned型的退出码
3._beginthreadex()在创建线程失败时返回0，而_beginthread()在创建线程失败时返回-1

AfxBeginThread (MFC)

也是对CreateThread接口的封装.它会new一个CWinThread对象，而且这个对象在线程结束时会自动删除.不便之处是无法获取它的状态.
如果用MFC编程，不要用CreateThread，如果只是使用Runtime Library，用_BegingThreadex，总之，不要轻易使用CreateThread.因为在MFC和CRT中的函数有可能会用到些它们所封装的公用变量.

等待信号

WaitForSingleObject

DWORD WaitForSingleObject( HANDLE hHandle,DWORDdwMilliseconds);
它可以等待如下几种类型的对象：
Event，Mutex，Semaphore，Process，Thread
有三种返回类型：
WAIT_OBJECT_0, 表示等待的对象有信号（对线程来说，表示执行结束）；
WAIT_TIMEOUT, 表示等待指定时间内，对象一直没有信号（线程没执行完）；
WAIT_ABANDONED 表示对象有信号，但还是不能执行一般是因为未获取到锁或其他原因.

WaitForMultiObject

DWORD WaitForMultipleObjects(DWORD nCount, CONST HANDLE *lpHandles, BOOLfWaitAll, DWORDdwMilliseconds);
四个参数分别是:
1.nCount，DWORD类型，用于指定句柄数组的数量
2. lphObjects，Pointer类型，用于指定句柄数组的内存地址
3. fWaitAll，Boolean类型，True表示函数等待所有指定句柄的Object有信号为止
4. dwTimeout，DWORD类型，用于指定等待的Timeout时间，单位毫秒，可以是INFINITE
当WaitForMultipleObjects等待多个内核对象的时候，如果它的bWaitAll 参数设置为false。其返回值减去WAIT_OBJECT_0 就是参数lpHandles数组的序号。如果同时有多个内核对象被触发，这个函数返回的只是其中序号最小的那个。如果为TRUE 则等待所有信号量有效再往下执行.
多个内核对象被触发时，WaitForMultipleObjects选择其中序号最小的返回。而WaitForMultipleObjects它只会改变使它返回的那个内核对象的状态。如果序号最小的那个对象频繁被触发，那么序号比它大的内核对象将得不到被处理的机会,怎么办?可以用双WaitForMultipleObjects检测机制,如下例子:

DWORD WINAPI ThreadProc(LPVOID lpParameter) 　　  
{ 　　  
    DWORD dwRet = 0; 　　  
    int nIndex = 0; 　　  
    while(1) 　　  
    {　  
        dwRet = WaitForMultipleObjects(nCount,pHandles,false,INFINITE); //返回值范围:WAIT_OBJECT_0至WAIT_OBJECT_0+nCount-1　  
        switch(dwRet) 　　  
        {  
            case WAIT_TIMEOUT: 　　  
                break; 　　  
            case WAIT_FAILED: 　　  
                return 1;  
            default:  
            {  
                nIndex = dwRet - WAIT_OBJECT_0; 　　  
                ProcessHanlde(nIndex++); 　　//同时检测其他的事件 　　  
                while(nIndex < nCount) //nCount事件对象总数 　　  
                { 　　  
                    dwRet = WaitForMultipleObjects(nCount - nIndex,&pHandles[nIndex],false,0); 　　  
                    switch(dwRet) 　　  
                    {  
                        case WAIT_TIMEOUT: 　　  
                            nIndex = nCount; //退出检测,因为没有被触发的对象了. 　　  
                            break;  
                        case WAIT_FAILED: 　　  
                            return 1; 　　  
                        default:  
                        {  
                            nIndex = dwRet - WAIT_OBJECT_0; 　　  
                            ProcessHanlde(nIndex++); 　　  
                        }  
                            break;  
                    }//switch结束  
                }//while结束  
            }//default结束  
                break;  
        }//switch结束  
  
    }//while结束  
    return 0;   
}

注意:WaitForMultiObjects最多只能等待MAXIMUM_WAIT_OBJECTS个kernal objects。MAXIMUM_WAIT_OBJECTS被定义为64,如果超出,可以进行第二次wait,接收剩余的事件.

线程同步

线程同步的方法:
Windows下有四种:临界区、互斥器、事件、信号量
Linux下最常用:互斥锁、条件变量和信号量
线程同步性能排序:
volatile读取 -->volatile写入–>Interlocked API(原子方式)–>SRWLock–>关键段–>内核对象
临界区(Critical Section)
关键段(critical section)在执行之前需独占一些共享资源的访问权,这种方式可让多行代码以”原子方式”(即除了当前线程,没有其他线程访问该资源)对资源进行操控.
对于系统层面来说,他也会调用其他线程,但它不会调度访问这些资源相关的线程.
工作原理:
EnterCriticalSection检查这些成员变量是否有线程正在访问:
1)如果没有线程在访问,EnterCriticalSection更新变量,表示调用线程已经获准对资源的访问，并立即返回，这样线程继续执行
2)如果调用线程已经获准访问资源(即在该线程之前已经用过EnterCriticalSection),那么EnterCriticalSection会更新变量,表示调用线程被获准访问的次数(这里需要注意的是LeaveCriticalSection数量必须和EnterCriticalSection数量相同,否则其他进程还是无法访问)
3)如果其他线程已经获准访问资源,EnterCriticalSection会使用一个事件内核对象把当前线程切换到等待状态.这点需要详细说明:进入关键段的时候它使用自旋锁对共享资源的”争用”,而不是立刻进入等待状态,进入内核模式;因为很多情况下共享资源不会占用太长时间,如果因为一个即将释放的资源而将线程切换内核模式将得不偿失.(线程从用户模式切换到内核模式大约需要1000个CPU周期)如果”争用”成功,EnterCriticalSection返回,继续执行代码段,如果失败,线程切换到等待状态.(SetCriticalSectionSpinCount改变自旋次数;多核才会这样尝试,不过现在基本都是多核)
参见:https://blog.csdn.net/louzi8888/article/details/50769788
(最后一个写日志的例子值得学习)
缺点:
能且只能用在一个进程中的多线程同步。可能陷入死锁，因为我们无法为进入关键段的线程设置最大等待时间.

互斥器(Mutexes)
和临界区类似,一个时间只能一个线程有mutex,就好像同一时间只能有一个线程进入critical section一样,但mutex通过牺牲速度提高灵活性,功能变得更强大.具体差别:
1)锁住一个未被拥有的mutex比锁住一个未被拥有的critical section花费几乎100倍的时间
2)mutex可以跨进程使用;critical section只能在一个进程使用.
3)等待mutex时,可以指定”结束等待”的时间长度,但critical section不行
造成这些差别的根本原因是mutex是内核对象,critical section非内核对象
使用mutex需要注意:
1)有时候由于某种原因线程结束前没有ReleaseMutex().针对这种情况,mutex有个非常重要的特性(这种机制在各种线程同步机制中独一无二):mutex不会被摧毁,mutex会被视为”未被拥有”以及”未被激活”,而下一个等待中的线程会被WAIT_ABANONED_0通知.
2)任何时候只要你想锁住超过一个以上的同步对象,你就有死锁的潜在病因;但如果你总是在相同时间把所有对象都锁住,可以避免这个问题.
例如如下示例可能潜在死锁的可能:

EnterCriticalSection(list1->critical_sec);
EnterCriticalSection(list2->critical_sec);
//list1,list2数据交换
LeaveCriticalSection(list1->critical_sec);
LeaveCriticalSection(list2->critical_sec);
正确的做法:
HANDLE arrHandles[2];
arrHandles[0] = list1->hMutex;
arrHandles[1] = list2->hMutex;
WaitForMultipleObjects(2, arrHandles, TRUE, INFINITE);
//list1,list2数据交换
ReleaseMutex(arrHandles[0]);
ReleaseMutex(arrHandles[1]);

信号量(semaphore)
理论上mutex是semaphore的一种退化,若你产生一个semaphore并令最大值为1,那就是一个mutex,因此mutex又称binary semaphore.我们知道,如果binary semaphore被一个线程拥有,那么其他线程就无法获得它的拥有权,但win32中这两种东西拥有权意义完全不一样,所以它们不能交换使用,semaphore不想mutex,它没有所谓的”wait abandoned”状态可以被其他线程侦测到.
每一个semaphore锁定动作成功semaphore的现值会减1,你可以使用任何一种wait…()函数来要求锁定一个semaphore.如果semaphore的现值不为0,wait…()函数会立刻返回,这和mutex很像(没有任何线程拥有mutex,wait…()函数立刻返回)
注意，如果锁定成功，你也不会收到semaphore的拥有权。因为可以有一个以上的线程同时锁定一个semaphore。所以谈semaphore的拥有权并没有太多实际意义。在semaphore身上并没有所谓“独占锁定”这种事情。也因为没有所有权的观念，一个线程可以反复调用wait…()函数以产生新的锁定。这和mutex绝不相同：拥有mutex的线程不论再调用多少次wait…()函数，也不会被阻塞住。
与mutex不同的是，调用ReleaseSemaphore()的那个线程，并不一定就得是调用wait…()的那个线程。
任何线程都可以在任何时间调用ReleaseSemaphore()，解除被任何线程锁定的semaphore。

临界区,互斥器,信号量的比较:

临界区	互斥器	信号量
CRITICAL_SECTION InitializeCriticalSection()	CreateMutex() OpenMutex()	CreateSemaphore
EnterCriticalSection()	WaitForSingleObject() WaitForMultipleObjects() MsgWaitForMultipleObjects()	WaitForSingleObject() WaitForMultipleObjects() MsgWaitForMultipleObjects() …
LeaveCriticalSection()	ReleaseMutex()	ReleaseSemaphore()
DeleteCriticalSection()	CloseHandle()	CloseHandle()

std::Mutex：

Mutex(互斥量)，隶属于C++11标准库，头文件#include
基本作用：互斥占有一个变量，一段时间内仅一个线程可以访问。
即该类可以限制对某物的访问，只有先获得许可才可访问某物，否则一般可设为阻塞等待。C++标准库的所有mutex都是不可拷贝的，也不可移动。
可重入：mutex,timed_mutex
重入锁指的是，当一个线程获得对象锁后，这个线程可以再次获得此对象上的锁，而其他线程不能获得；其意义在于防止死锁；
不可重入：recursive_mutex,recursive_timed_mutex
不可重入的锁在lock或try_lock一个已经被当前线程lock的锁时会导致死锁。
Mutex锁：
lock:如果mutex未上锁，则将其上锁。否则如果已经其它线程lock，则阻塞当前线程
try_lock:如果mutex未上锁，则将其上锁。否则返回false，并不阻塞当前线程
timed_mutex:
try_lock_for(duration):timed_mutex未上锁，则将其上锁，否则阻塞当前线程，但最长只阻塞duration表示的时间段
try_lock_until(time_point)：若阻塞，阻塞到time_point时间点就不阻塞
std::unique_lock和std::lock_guard
例如std::lock_guardstd::mutex lck(g_mt); 在变量lck的作用域生效,离开作用域析构时自动解锁;相对于lock_guard,unique的优势是能够在需要等待返回的地方暂时解锁,等到返回的时候再重新上锁,当然这是花费空间的代价来达到的.例如:
std::unique_lockstd::mutex lk(mut_);
cond_.wait(lk, [this]{return !que_.empety();});
第二句在等待返回的时候暂时解锁,获取到返回信息再重新上锁

boost::mutex

shared_lock是read lock,共享锁。被锁后仍允许其他线程执行同样被shared_lock的代码。这是一般做读操作时的需要。
unique_lock是write lock，独占锁。被锁后不允许其他线程执行被shared_lock或unique_lock的代码。在写操作时，一般用这个，可以同时限制unique_lock的写和share_lock的读
scoped_lock 区域锁，是RALL(Resource Acquisition Is Initialization)模式在锁上面的具体应用;翻译成中文叫“资源获取即初始化”，最早是由C++的发明者 Bjarne Stroustrup为解决C++中资源分配与销毁问题而提出的。RAII的基本含义就是：C++中的资源（例如内存，文件句柄等等）应该由对象来管理，资源在对象的构造函数中初始化，并在对象的析构函数中被释放。STL中的智能指针就是RAII的一个具体应用。RAII在C++中使用如此广泛，甚至可以说，不会RAII的裁缝不是一个好程序员。

thread对象

⭐join和detach的区别
thread::join() 被调用后，调用它的线程会被block，直到线程的执行被完成。这是一种可以直到线程已结束的机制。当thread::join返回时，OS执行的线程已完成，c++线程对象可以被销毁
thread::detach()被调用后，执行的线程从对象中被分离，不再被一个线程对象所表达，二者相互独立。c++线程对象可以被销毁，同时os执行的线程可以继续。如果想知道执行的线程何时结束就需要一些其他机制。join()函数在那个thread对象上不能再被调用，因为它已经不再和一个执行的线程相关联。
去销毁一个“joinable”的c++线程对象会被认为是一种错误。要销毁一个c++线程对象，要么join()需要被调用(并等待结束),要么detach()被调用。如果一个c++线程对象当销毁时仍可被join会抛出异常。
c++线程对象不被表达为执行的线程的其他情况(即unjoinable):
1.默认构造的线程对象不表达为执行的线程
2.被移开的线程不表达为执行的线程
在std::thread的析构函数中，如果线程没被join或detach，std::terminate会被调用，因此执行析构前总是要么join，要么detach
当一个程序终止时(如main)，剩下的后台的detached线程执行不会再被等待；相反他们的执行会被挂起并且它们的本地线程对象会被销毁。这意味着这些线程的栈不是完好无损的，因此一些洗后函数不会被执行。因此我们应该使用join；除非你需要更灵活并且想要独立提供一种同步机制等待线程完成，在这种情况下你应该使用detach.

s_ky_

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
多线程个人总结

CreateThread (windows API)使用此接口一般要求结束时调用CloseHandle关闭句柄.值得注意的是:如果线程中使用了诸如strtok()等函数（_tiddata结构成员的注释标注了这些函数），C运行库会尝试读取该线程的tiddata，如果没有，则会分配一个。这样在使用CloseHandle()关闭句柄时，tiddata未被释放，造成内存泄露.使用CreatThre...
复制链接

扫一扫

专栏目录