windows 线程同步

Windows 临界区，内核事件，互斥量，信号量。

临界区，内核事件，互斥量，信号量，都能完成线程的同步，在这里把他们各自的函数调用，结构定义，以及适用情况做一个总结。

临界区:

适用范围：它只能同步一个进程中的线程，不能跨进程同步。一般用它来做单个进程内的代码快同步,效率比较高。

相关结构：CRITICAL_SECTION  _critical

相关方法：

/*初始化，最先调用的函数。没什么好说的，一般windows编程都有类似初始化的方法*/

InitializeCriticalSection(& _critical)

/*释放资源，确定不使用_critical时调用，一般在程序退出的时候调用。如果以后还要用_critical，则要重新调用InitializeCriticalSection

*/

DeleteCriticalSection(& _critical)

/*

把代码保护起来。调用此函数后，他以后的资源其他线程就不能访问了。

*/

EnterCriticalSection（& _critical）

/*

离开临界区，表示其他线程能够进来了。注意EnterCritical和LeaveCrticalSection必须是成对出现的!当然除非你是想故意死锁！

*/

LeaveCriticalSection(& _critical)

代码Demo

临界区
#include "stdafx.h"
int thread_count = 0;
/*Mutex mutex1;*/
CRITICAL_SECTION g_cs;
DWORD CALLBACK thread_proc(LPVOID params)
{
    for(int i = 0; i < 10; ++i)
    {
            //synchronized(mutex1)
            EnterCriticalSection(&g_cs);
            {
                for(char c = ‘A‘; c <= ‘Z‘; ++c)
                {
                    printf("%c",c);
                }
                printf("\n");
            }
            LeaveCriticalSection(&g_cs);
    }
    thread_count--;
    return 0;
}

int _tmain(int argc, _TCHAR* argv[])
{
    InitializeCriticalSection(&g_cs);
    thread_count = 4;
    CreateThread(0, 0, thread_proc, 0, 0, 0);
    CreateThread(0, 0, thread_proc, 0, 0, 0);
    CreateThread(0, 0, thread_proc, 0, 0, 0);
    CreateThread(0, 0, thread_proc, 0, 0, 0);
    while (thread_count) 
        Sleep(0);
    getchar();
    DeleteCriticalSection(&g_cs);
    return 0;

内核事件：

适用范围：多用于线程间的通信，可以跨进程同步。

相关结构: HANDLE hEvent;

相关方法：

/*

初始化方法，创建一个事件对象，第一个参数表示安全属性，一般情况下，遇到这类型的参数直接给空就行了，第二个参数是否是人工重置。（内核时间有两种工作模式：人工重置和自动重置。其区别会在下面提到。）。第三个参数是初始状态，第四个参数事件名称。

*/

hEvent = CreateEvent（NULL,FALSE,FALSE,NULL);

/*

等待单个事件置位，即线程会在这个函数阻塞直到事件被置位，SetEvent。

如果是自动重置事件，则在此函数返返回后系统会自动调用ResetEvent（hEvnet），重置事件，保证其他线程不能访问。

如果是人工重置事件，则在此函数返回以后，系统的其他线程能继续访问。

第二个参数说明等待事件，INIFINET表示一直等待。

*/

WatiForSingleObject(hEvent,INIFINET)

/*

置位事件，只要使事件置位线程才能进去访问。即WatiForSingleObject(hEvent,INIFINET)才返回

*/

SerEvent(hEvent);

/*

重置事件,使得WatiForSingleObject（）不返回

*/

ResetEvent(hEvent)

/*

等待多个事件对象。参数nCount指定了要等待的内核对象的数目，存放这些内核对象的数组由lpHandles来指向。fWaitAll对指定的这nCount个内核对 象的两种等待方式进行了指定，为TRUE时当所有对象都被通知时函数才会返回，为FALSE则只要其中任何一个得到通知就可以返回。 dwMilliseconds在这里的作用与在WaitForSingleObject（）中的作用是完全一致的。如果等待超时，函数将返回 WAIT_TIMEOUT。如果返回WAIT_OBJECT_0到WAIT_OBJECT_0+nCount-1中的某个值，则说明所有指定对象的状态均 为已通知状态（当fWaitAll为TRUE时）或是用以减去WAIT_OBJECT_0而得到发生通知的对象的索引（当fWaitAll为FALSE 时）

*/

WaitForMultiObjects(DWORD nCount, // 等待句柄数

　CONST HANDLE *lpHandles, // 句柄数组首地址

BOOL fWaitAll, // 等待标志

　DWORD dwMilliseconds // 等待时间间隔)

/*

打开一个命名的事件对象，可以用来跨进程同步

*/

HANDLE OpenEvent(
DWORD dwDesiredAccess, // 访问标志
BOOL bInheritHandle, // 继承标志
LPCTSTR lpName // 指向事件对象名的指针
);

测试代码

内核事件
#include "stdafx.h"
/*#include "Mutex.h"*/
int thread_count = 0;
/*Mutex mutex1;*/
/*CRITICAL_SECTION g_cs;*/
HANDLE hEvent;
DWORD CALLBACK thread_proc(LPVOID params)
{
    for(int i = 0; i < 10; ++i)
    {
            //synchronized(mutex1)
            //EnterCriticalSection(&g_cs);
            
            WaitForSingleObject(hEvent,INFINITE);
            {    
                for(char c = ‘A‘; c <= ‘Z‘; ++c)
                {
                    printf("%c",c);
                    Sleep(1);
                }
                printf("\n");
            }
            SetEvent(hEvent);
            //LeaveCriticalSection(&g_cs);
    }
    thread_count--;
    return 0;
}

int _tmain(int argc, _TCHAR* argv[])
{
    //InitializeCriticalSection(&g_cs);
    hEvent = CreateEvent(NULL,FALSE,FALSE,NULL);
    SetEvent(hEvent);
    thread_count = 4;
    CreateThread(0, 0, thread_proc, 0, 0, 0);
    CreateThread(0, 0, thread_proc, 0, 0, 0);
    CreateThread(0, 0, thread_proc, 0, 0, 0);
    CreateThread(0, 0, thread_proc, 0, 0, 0);
    while (thread_count) 
        Sleep(0);
    getchar();
    //DeleteCriticalSection(&g_cs);
    return 0;
}

互斥量：

适用范围：可以跨进程同步，还可以用来保证程序只有一个实例运行（创建命名互斥量）,也可以用来做线程间的同步

相关结构：HANDLE hMutex;

相关方法：

/*

创建互斥量，初始化的工作

参数一为安全选项，一般为空

参数二表示当前互斥量是否属于某个线程，一般为空

参数三互斥量的名称，如果需要跨进程同步或者需要保证程序只有一个实例运行，则需要设置，其他情况一般为空。

*/

CreateMutex(NULL,FALSE,NULL)

WaitForSingleObject(hMutex,INIFINET);//同事件对象

/*

释放互斥量，以使得其他线程可以访问。

*/

ReleaseMutex(hMutex)

/*

在互斥对象通知引 起调用等待函数返回时，等待函数的返回值不再是通常的WAIT_OBJECT_0（对于WaitForSingleObject（）函数）或是在 WAIT_OBJECT_0到WAIT_OBJECT_0+nCount-1之间的一个值（对于WaitForMultipleObjects（）函 数），而是将返回一个WAIT_ABANDONED_0（对于WaitForSingleObject（）函数）或是在WAIT_ABANDONED_0 到WAIT_ABANDONED_0+nCount-1之间的一个值（对于WaitForMultipleObjects（）函数）。

*/

WaitForMultiObjects(DWORD nCount, // 等待句柄数

　CONST HANDLE *lpHandles, // 句柄数组首地址

BOOL fWaitAll, // 等待标志

　DWORD dwMilliseconds // 等待时间间隔)

/*

打开一个已经创建好了的命名互斥量，用于跨进程同步

*/

HANDLE OpenMutex(
DWORD dwDesiredAccess, // 访问标志
BOOL bInheritHandle, // 继承标志
LPCTSTR lpName // 互斥对象名
);

测试demo

互斥量
#include "stdafx.h"
/*#include "Mutex.h"*/
int thread_count = 0;
/*Mutex mutex1;*/
/*CRITICAL_SECTION g_cs;*/
//HANDLE hEvent;
HANDLE hMutex;
DWORD CALLBACK thread_proc(LPVOID params)
{
    for(int i = 0; i < 10; ++i)
    {
            //synchronized(mutex1)
            //EnterCriticalSection(&g_cs);
            WaitForSingleObject(hMutex,INFINITE);
            //WaitForSingleObject(hEvent,INFINITE);
            //{    
                for(char c = ‘A‘; c <= ‘Z‘; ++c)
                {
                    printf("%c",c);
                    Sleep(1);
                }
                printf("\n");
            //}
            //SetEvent(hEvent);
            ReleaseMutex(hMutex);
            //LeaveCriticalSection(&g_cs);
    }
    thread_count--;
    return 0;
}

int _tmain(int argc, _TCHAR* argv[])
{
    //InitializeCriticalSection(&g_cs);
    //hEvent = CreateEvent(NULL,FALSE,FALSE,NULL);
    //SetEvent(hEvent);
    hMutex = CreateMutex(NULL,FALSE,NULL);
    thread_count = 4;
    CreateThread(0, 0, thread_proc, 0, 0, 0);
    CreateThread(0, 0, thread_proc, 0, 0, 0);
    CreateThread(0, 0, thread_proc, 0, 0, 0);
    CreateThread(0, 0, thread_proc, 0, 0, 0);
    while (thread_count) 
        Sleep(0);
    getchar();
    //DeleteCriticalSection(&g_cs);
    return 0;
}

注意事项：所有的同步操作的必须成对存在，即锁一对象，一定要释放一个对象。但是如果在保护的代码快中发生异常，程序流程发生意外跳转而没有释放锁对象，导致程序进入死锁。所以在程序中必要的异常处理是必须的，但是C++中没有finally这样的关键字来保证不管是否发生异常都会执行的代码快。那怎么办呢？这就需要对C++的异常加一些小技巧来处理了......

时间： 2024-10-23 12:21:05

windows 线程同步的相关文章

Windows线程同步

说到windows线程同步的方法,有循环锁,临界区(关键代码段),内核对象(Event,Semaphore,Mutex).甚至进程,线程handle等等. 说说用法: 临界区和mutex都可以用于控制共享资源的互斥访问,不同点是 临界区是用户级对象,消耗小,速度快,但是不能跨进程.mutex是内核对象速度慢,但是可以跨进程. semaphore可以用来进行资源控制,信号量的两个关键参数,现有资源数和最大资源数,可以用于对资源的控制,通过ReleaseSemaphore对资源增加,WaitFor*

Windows线程同步总结

Windows线程同步 Windows的线程同步可以利用互斥对象来实现,也可以使用事件对象,关键代码段来实现. 1 事件对象实现线程同步 <1>Event对象创建函数 事件对象的创建事件对象属于内核对象,它包含以三个成员:使用计数,是否是自动重置还是人工重置的布尔值,通知状态的布尔值. HANDLE CreateEvent( LPSECURITY_ATTRIBUTESlpEventAttributes, BOOLbManualReset, BOOLbInitialState, LPCSTRlp

windows线程同步之原子锁（原子访问）

原子锁(原子访问):一个线程在访问某个资源的同时必须确保其他线程不会同时访问此资源. 没有实现原子锁的结果: //定义一个全局变量 long g_lx = 0; DWORD WINAPI ThreadFunc1(PVOID pvParam){ for( int index=0; index<10000; index++ ) { g_lx++: //g_lx加1: } return 0: } DWORD WINAPI ThreadFunc2(PVOID pvParam){ for( int ind

Windows线程同步（未完）

先介绍一个创建线程的API,参考:https://msdn.microsoft.com/en-us/library/windows/desktop/ms682453%28v=vs.85%29.aspx Creates a thread to execute within the virtual address space of the calling process. HANDLE WINAPI CreateThread( _In_opt_ LPSECURITY_ATTRIBUTES lpThr

windows 线程同步学习测试-1

环境win7旗舰64位系统,vs2013,AMD fx™4100 Auad-core processor ,8G内存, 看<windows核心编程>线程同步一章,看到有说g_x++会不同步的问题,试着写些代码加深印象.发现+1太快了,看不出效果,于是for循环了1亿次.代码如下: #include "stdafx.h" using std::cout; using std::endl; using std::cin; unsigned __stdcall ThreadFun

Windows线程同步【2】临界区

临界区是线程同步的一种实现方式.Windows提供了4个关于临界区的函数(InitializeCriticalSection,EnterCriticalSection,LeaveCriticalSection,DeleteCriticalSection),要想使用这些函数,必须先有一个临界区变量, CRITICAL_SECTION cs; 临界区变量,不能复制,不能移动,也不能读取里面的字段(可以取临界区变量的地址).总而言之,我们在编写程序时,必须把临界区变量当成一个黑箱,一切对临界区的操作必

Windows线程同步【3】互斥锁（Mutex）

我们前面讲过的临界区,如同一个小房间,张三进去了,李四就不能进,如果李四要进,必须等张三出来. 今天我们要讲的互斥锁,像一个物件,这个物件只能同时被一个线程持有.如此一来,便可以通过互斥锁来实现线程的同步. 一.创建 创建互斥锁的方法是调用函数CreateMutex: CreateMutex(&sa, bInitialOwner, szName); 第一个参数是一个指向SECURITY_ATTRIBUTES结构体的指针,一般的情况下,可以是nullptr. 第二个参数类型为BOOL,表示互斥锁创

Windows线程同步【5】条件变量（Condition Variable）

一.引言 假设有一个任务,由我和张三共同完成.张三把寄来的文稿初步审阅后放入一个队列,我负责将这个队列中的文稿进行审批,决定刊登与否.张三审阅一份文稿需要15分钟,我处理一个文稿需要2分钟. 如果将张三和我看作两个线程,那么我们共享一个队列的数据.按照一般的多线程思路,他每隔一段时间往队列中放入数据,我每隔一段时间检查一下队列中是否有数据,若有,则处理之. 若我们按照上面的方式工作,则大部分的时间,我只是在干等着,所以,这是一种比较低效的方式. 但换一种方式之后,情况就好很多了.他每把一个文稿放

Windows线程同步【4】读写锁（RWMutex）

在视频播放机程序中,经常采用这样的架构: 一个负责读文件的线程,负责从媒体文件中读取数据并将数据包放入一个包队列(queue),另外有多个线程从这个包队列中取包并解码,然后交给负责显示的线程以便显示图像.于是,便形成了多个线程共享一个队列,一个写,多个只读不写的情形. 在很多时候,我们都会遇到一个写线程(负责写数据),多个读线程(负责读数据)的情形.在这类情形下,当然可以用锁来保证每个线程对共享数据的访问是独占的.但这样的做法在此情形下是低效的,因为它会使得一个读线程在读数据时另外的读线程只能干