精华内容
下载资源
问答
  • 通过对mutex的使用,达到进程内多个线程的互斥访问临界资源
  • 进程间互斥访问临界资源

    千次阅读 2019-07-11 03:42:37
    进程间互斥访问临界资源 1、使用临界区变量 HANDL g_hMutex; HANDLE g_hThread[2]; main() { g_hMutex=CreateMutex(NULL,FALSE,NULL); g_hThread[0]=CreateThread(..); g_hThread[1]=CreateThread(..); } ...

    进程间互斥访问临界资源

     

    1、使用临界区变量
    HANDL   g_hMutex;
    HANDLE   g_hThread[2];
    main()
    {
          g_hMutex=CreateMutex(NULL,FALSE,NULL);
          g_hThread[0]=CreateThread(..);
          g_hThread[1]=CreateThread(..);

    }

    LRESULT   CALLBACK   Thread1Proc(LPVIOD   lParam)
    {
          WaiteForSingleObject(g_hMutex,INIFINTE);
          //Read   File   Operation   hear
          ReleaseObject(g_hMutex);
    }

    LRESULT   CALLBACK   Thread2Proc(LPVIOD   lParam)
    {
          //同上
    }

    最后要   CloseHandle(g_hMutex);

     

     

     


    2、Section Object
    CRITICAL_SECTION CS;  {声明一个 CriticalSection 结构类型变量; 它应该是全局的}
    InitializeCriticalSection(CS); {初始化}
    EnterCriticalSection(CS);   {开始: 轮到我了其他线程走开}

    ....(临界资源)
    LeaveCriticalSection(CS);   {结束: 其他线程可以来了}
    DeleteCriticalSection(CS);   {删除: 注意不能过早删除}

     

    转载于:https://www.cnblogs.com/sql4me/archive/2010/10/19/1855273.html

    展开全文
  • Windows系统——多线程互斥访问临界资源 实现代码 /* author : eclipse email : eclipsecs@qq.com time : Fri Apr 24 15:45:42 2020 */ #include<bits/stdc++.h> #include<windows.h> using namespace ...

    Windows系统——多线程互斥访问临界资源

    实现代码

    /*
    author : eclipse
    email  : eclipsecs@qq.com
    time   : Fri Apr 24 15:45:42 2020
    */
    #include<bits/stdc++.h>
    #include<windows.h>
    using namespace std;
    
    CRITICAL_SECTION mutex;
    const int THREAD_NUM = 5;
    int value = 25;
    
    DWORD CALLBACK print(LPVOID param) {
        for (int i = 0; i < 5; i++) {
            EnterCriticalSection(&mutex);
            printf("%d\n", value--);
            LeaveCriticalSection(&mutex);
        }
        return 0;
    }
    
    int main(int argc, char const *argv[])
    {
        InitializeCriticalSection(&mutex);
        DWORD threadId[THREAD_NUM];
        HANDLE threadHandle[THREAD_NUM];
        for (int i = 0; i < THREAD_NUM; i++) {
            if (!(threadHandle[i] = CreateThread(NULL, 0, print, NULL, 0, &threadId[i]))) {
                printf("Thread create error!\n");
                abort();
            }
        }
        WaitForMultipleObjects(THREAD_NUM, threadHandle, true, INFINITE);
        DeleteCriticalSection(&mutex);
        return 0;
    }
    
    

    临界资源

    • 临界资源
      临界资源指的是允许仅允许一个线程(进程)在一个时间段使用的资源,例如外设、一些共享变量等,多个线程必须互斥访问临界资源
    • 初始化临界区
    WINBASEAPI
    VOID
    WINAPI
    InitializeCriticalSection(
        _Out_ LPCRITICAL_SECTION lpCriticalSection
        );
    

    参数lpCriticalSection为临界区指针

    • 进入区
    WINBASEAPI
    VOID
    WINAPI
    EnterCriticalSection(
        _Inout_ LPCRITICAL_SECTION lpCriticalSection
        );
    

    参数lpCriticalSection为临界区指针

    • 临界区
      临界区指的是访问临界资源的那一段代码
    • 退出区
    WINBASEAPI
    VOID
    WINAPI
    LeaveCriticalSection(
        _Inout_ LPCRITICAL_SECTION lpCriticalSection
        );
    

    参数lpCriticalSection为临界区指针

    • 删除临界区
    WINBASEAPI
    VOID
    WINAPI
    DeleteCriticalSection(
        _Inout_ LPCRITICAL_SECTION lpCriticalSection
        );
    
    • 功能
      上述函数保证多线程能够互斥地访问临界资源,上述实现中多线程互斥地访问共享全局变量value,当一个线程进入临界区后,其他试图进入临界区的线程将被阻塞,直到进入临界区的线程离开临界区
    • 临界区调度准则
    1. 空闲让进
    2. 忙则等待
    3. 有限等待
    4. 让权等待

    注意

    • 互斥访问临界资源
      若在上述实现中注释掉 EnterCriticalSection()函数和LeaveCriticalSection()函数,则不能保证多线程互斥地访问临界资源,多线程同时访问共享全局变量value,将造成意料之外的结果,输出顺序被打乱
    25
    22
    19
    18
    17
    16
    23
    15
    14
    13
    12
    24
    11
    10
    21
    8
    7
    6
    9
    5
    20
    4
    3
    2
    1
    
    

    输出结果

    25
    24
    23
    22
    21
    20
    19
    18
    17
    16
    15
    14
    13
    12
    11
    10
    9
    8
    7
    6
    5
    4
    3
    2
    1
    
    

    最后

    • 由于博主水平有限,不免有疏漏之处,欢迎读者随时批评指正,以免造成不必要的误解!
    展开全文
  • 进程间同步和互斥临界资源

    千次阅读 2016-03-20 18:34:25
    简介 各进程采取互斥的方式,实现共享的资源称作临界资源...显然,若能保证诸进程互斥地进入自己的临界区,便可实现诸进程对临界资源互斥访问。为此,每个进程在进入临界区之前,应先对欲访问的临界资源进行检查

    简介

    各进程采取互斥的方式,实现共享的资源称作临界资源。
    属于临界资源的硬件有打印机、 磁带机等,软件有消息缓冲队列、 变量数组、缓冲区等。 诸进程间应采取互斥方式,实现对这种资源的共享。
    每个进程中访问临界资源的那段代码称为 临界区。显然,若能保证诸 进程互斥地进入自己的 临界区,便可实现诸进程对临界资源的互斥访问。为此,每个进程在进入 临界区之前,应先对欲访问的临界资源进行检查,看它是否正被访问。如果此刻该临界资源未被访问,进程便可进入 临界区对该资源进行访问,并设置它正被访问的标志;如果此刻该临界资源正被某进程访问,则本进程不能进入 临界区
    在操作系统中,有 临界区的概念。 临界区内放的一般是被1个以上的进程或线程(以下只说进程)共用的数据。
    临界区内的数据一次只能同时被一个进程使用,当一个进程使用临界区内的数据时,其他需要使用临界区数据的进程进入等待状态。
    操作系统需要合理的分配临界区以达到 多进程的同步和互斥关系,如果协调不好,就容易使系统处于不安全状态,甚至出现 死锁现象。

    事例

    例如,打印机不可能同时打印多个进程的结果,若将一个进程的结果打印几行,再打印另一个进程的结果,这会使打印的结果变得无法使用。所以两个或两个以上进程由于不能同时使用同一临界资源,只能一个进程使用完了,另一进程才能使用。
    除了物理设备外,还有很多 软资源如变量、 表格队列等也都属于临界资源,如果同时使用,同样会引起与时间相关的错误。例如,有两个进程P1和P2共享一个变量 count,P1或P2的功能是,每执行完某些操作后,将count的值取出加1,R1和R2是 工作寄存器。当两个进程按下述顺序执行时:
    P1:操作序列;
    Rl=count;
    R1=R1+1;
    count=R1;
    P2:操作序列;
    R2=count;
    R2=R2+1;
    count=R2;
    其结果使count的值增加了2;倘若P1和P2按另一种顺序执行,例如:
    P1:R1=count;
    P2:R2=count;
    P1:Rl=Rl+1;count=Rl;
    P2:R2=R2+1;count=R2;
    按此执行序列,虽使P1和P2都各自对count做了加1操作,但最后的count值却只增加了1,即出现了结果不确定的错误。显然这种错误与执行顺序有关,又叫与时间相关的错误。之所以出现这种错误,是由于变量count是临界资源,P1和P2不能同时使用,即仅当进程P1对count进行修改并退出后,才允许进程P2访问和修改,那么就可以避免上述的错误结果。
    展开全文
  • Ini2alizeCri2calSec2on()初始化临界区,然后建?两个?线程,在两个?线程 中使?全局变量 count 的前、后分别使?EnterCri2calSea2on()进?临界区LeaveCri2calSec2on()退出临 界区,等两个?...

    题目:

    完成两个⼦线程之间的互斥。在主线程中使⽤系统调⽤ CreateThread()创建两个⼦线程,并使两个⼦
    线程互斥的使⽤全局变量 count。

    代码:

    
    
    
    // 03.cpp : Defines the entry point for the console application.
    //
    
    #include "stdafx.h"
    #include "03.h"
    
    #ifdef _DEBUG
    #define new DEBUG_NEW
    #undef THIS_FILE
    static char THIS_FILE[] = __FILE__;
    #endif
    
    /
    // The one and only application object
    
    CWinApp theApp;
    
    using namespace std;
    
    // 定义临界资源
    static int count =5; 
    //定义盛放线程的句柄
    static HANDLE h1; 
    static HANDLE h2; 
    // lpCriticalSection:指出临界区对象的地址。定义指向临界区对象的地址指针.
    LPCRITICAL_SECTION hCriticalSection;
     //定义临界区
    CRITICAL_SECTION Critical;
    //声明方法头
    void func1(); 
    void func2(); 
    
    
    
    //主线程部分——main方法
    int _tmain(int argc, TCHAR* argv[], TCHAR* envp[]) 
    {int nRetCode=0; 
    // DWORD是双字节数据类型。
     DWORD dwThreadID1, dwThreadID2; 
     //CRITICAL_SECTION Critical;
    // LPCRITICAL_SECTION hCriticalSection;
    //将指向临界区对象的指针指向临界区
    hCriticalSection=&Critical; 
    // 初始化临界区
    /*初始化临界区
    Ini2alizeCri2calSec2on()?于初始化临界区对象。
    原型:
    VOID Ini2alizeCri2calSec2on(
    LPCRITICAL_SECTION lpCriticalSection 
    );
    参数说明:
    lpCriticalSection:指出临界区对象的地址。
    返回值:
    该函数没有返回值。*/
     //CRITICAL_SECTION Critical;
    // LPCRITICAL_SECTION hCriticalSection;
    InitializeCriticalSection(hCriticalSection);
    //创建线程 func1 
    /*	hHandle=CreateThread((LPSECURITY_ATTRIBUTES) NULL,
    		0,
    		(LPTHREAD_START_ROUTINE) ThreadName,//线程要执行的函数
    		(LPVOID)NULL,//NULL表示函数不用给他传参数
    		0,//为0表示创建这个线程之后立马调用
    		&ThreadID);
    	hHandle1=CreateThread((LPSECURITY_ATTRIBUTES) NULL,
    		0,
    		(LPTHREAD_START_ROUTINE) ThreadName1,
    		(LPVOID)NULL,
    		0,
    		&ThreadID1);*/
    		/*sta2c HANDLE h1; 
    sta2c HANDLE h2; */
    /* DWORD dwThreadID1, dwThreadID2; */
    //creatThread()创建进程,返回用来控制线程的句柄
    h1=CreateThread((LPSECURITY_ATTRIBUTES)NULL, 
    0, 
    (LPTHREAD_START_ROUTINE)func1, 
    (LPVOID)NULL, 
    0,
    &dwThreadID1); //这是个什么?
    if (h1==NULL) printf("Thread1 create FAIL!\n"); 
    else printf("Thread1 create Success!\n"); 
    
    
    
    //创建第二个线程
    h2=CreateThread((LPSECURITY_ATTRIBUTES)NULL, 
    0, 
    (LPTHREAD_START_ROUTINE)func2, 
    (LPVOID)NULL, 
    0,
    &dwThreadID2); 
    if (h2==NULL) printf("Thread2 create FAIL!\n"); 
    else printf("Thread2 create Success!\n");
    //主线程休眠1s
    Sleep(1000); //这里如果改成100就会导致无法进入线程2,为何?
    /*函数CloseHandle()用于关闭已打开的对象的句柄,其作用与释放动态申请的内存空间类似,这样可以释放系统资源,使线程安全运行.
    原型:
    BOOL CloseHandle(HANDLE hObject);
    参数说明:
    hObject:已打开对象的句柄.
    返回值:
    如果函数调用成功,则返回值为非0值;如果函数调用失败,则返回值为0.若要得到更多的错误信息,调用函数GetLastError()查询.*/
    //existThread()关闭线程,释放线程所需要的资源.但c++对象不撤销。
    //将子线程关闭
    CloseHandle(h1); 
    CloseHandle(h2); //关闭线程的句柄就可以关闭线程吗?
    /*// lpCriticalSection:指出临界区对象的地址。定义指向临界区对象的地址指针.
    LPCRITICAL_SECTION hCriticalSection;
     //定义临界区
    CRITICAL_SECTION Critical;*/
    /*删除临界区
    DeleteCri2calSec2on()删除与临界区有关的所有系统资源。
    原型:
    VOID DeleteCri2calSec2on(
    LPCRITICAL_SECTION lpCri2calSec2on 
    );
    参数说明:
    lpCri2calSec2on:指出临界区对象的地址。
    返回值:
    该函数没有返回值。*/
    DeleteCriticalSection(hCriticalSection); //删除临界区
    // 线程状态码,退出所在线程
    /*撤销线程
    ExitThread()用于撤销当前进程.
    原型:
    VOID ExitThread(
    DWORD dwExitCode);   //线程返回码
    参数说明:
    dwExitCode:指定线程返回码,可以调用GetExitCodeThread()查询返回码的含义.
    返回值:
    该函数没有返回值.*/
    ExitThread(0); //什么零不零的?
    return nRetCode; //?
    } 
    
    
    
    void func2() 
    { int r2; 
    /*进?临界区
    EnterCri2calSec2on()等待进?临界区的权限,当获得该权限后进?临界区。
    原型:
    VOID EnterCri2calSec2on(
    LPCRITICAL_SECTION lpCri2calSec2on 
    );
    参数说明:
    lpCri2calSec2on:指出临界区对象的地址。
    返回值:
    该函数没有返回值*/
     EnterCriticalSection (hCriticalSection);
     //临界资源有5个
     r2=count; 
     _sleep(100); //为什么还要加_
    r2=r2+1; 
    count=r2; 
    //7
    printf("count in func2=%d\n",count); 
    /*退出临界区
    LeaveCri2calSec2on()释放临界区的使?权限。
    原型:
    VOID LeaveCri2calSec2on( 
    LPCRITICAL_SECTION lpCri2calSec2on 
    );
    参数说明:
    lpCri2calSec2on:指出临界区对象的地址。
    返回值:
    该函数没有返回值*/
    LeaveCriticalSection (hCriticalSection); 
    } 
    
    
    
    void func1() 
    { int r1; 
     EnterCriticalSection (hCriticalSection); 
     r1=count; 
    _sleep(500); 
    r1=r1+1; 
    count=r1; 
    //6
    printf("count in func1=%d\n",count); 
    LeaveCriticalSection (hCriticalSection);
    }
    

    心得:

    1.要想线程2可以执行,就必须在删除临界区之前,让线程1释放临界资源。简单说,就是创建线程和删除临界区之间等待的时间<线程2执行完和释放临界资源之间的等待时间。
    等于也不行哦

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    疑问:

    1.线程1和线程2共用一个临界区吗?因为只删除了一个临界区。
    2. 指出临界区对象的地址。定义指向临界区对象的地址指针:
    LPCRITICAL_SECTION hCriticalSection;
    定义临界区:
    CRITICAL_SECTION Critical;
    就像int a;
    int *p=&a;一样吗?
    3.什么用
    在这里插入图片描述
    4.在这里插入图片描述
    5.关闭句柄就可以关闭线程吗?
    在这里插入图片描述
    6.0…这个零不是认为人为写上去的吗,如何具有标识作用在这里插入图片描述
    7.线程1和线程2是同时创建的吗?
    8.等0.499秒关闭临界区,线程1等0.5秒秒释放临界资源,为什么线程2申请不到临界资源,创建线程2不也花了很长时间吗?

    展开全文
  • 临界区的互斥控制_SetEvent置句柄为有信号状态配合WaitForSingleObject使用_INFINITE等待其运行结束
  • 互斥:同一时间,当只保证互斥,则可以保证临界资源访问不会造成临界资源数据的二义性,但是有可能占有临界资源的进程一直在占有,导致后面进程访问等待时间比较长 同步:保证对临界资源访问的合理性 1. 互斥 如果有...
  • 文章目录1,临界资源2,互斥锁的初始化pthread_mutex_init()3,申请锁pthread_mutex_lock()4,释放锁pthread_mutex_unlock()5,线程互斥---示例 1,临界资源 临界资源 · 一次只允许一个任务(进程、线程)访问的...
  • vc++中使用临界区CriticalSection的例子.zip
  • 在多道程序环境下,存在着临界资源,它是指多进程存在时必须互斥访问的资源。也就是某一时刻不允许多个进程同时访问,只能单个进程的访问。我们把这些程序的片段称作临界区或临界段,它存在的目的是有效的防止竞争...
  • QT多线程临界资源互斥

    千次阅读 2017-11-28 19:41:48
    多线程是个老梗,一般都会遇到,同样临界资源互斥访问也是一个老生长谈的问题了。这里把最近使用的一种方法分享一下。 问题场景:主线程根据一定条件创建多个子线程,子线程执行的是同一个类不同实例的方法,该...
  • 临界资源/临界区/互斥

    千次阅读 2017-12-25 09:39:25
    一次仅允许一个进程使用的资源称为临界资源。许多物理设备都属于临界资源,如输入机、打印机、磁带机等。 各进程采取互斥的方式,实现共享的资源称作临界资源。 属于临界资源的硬件有打印机、磁带机等,软件...
  • 临界资源与临界区 临界资源(critical resource):一次只能供一个...为了实现临界资源互斥访问,只要做到进程互斥地进去自己的临界区,便可以实现进程对临界资源互斥访问。 同步机制 为实现各进程互质地访...
  • 进程互斥访问临界

    千次阅读 2019-10-21 20:17:35
    进程对临界资源的访问需要互斥,其需要遵从以下四个原则: 1、空闲让进:临界区空闲时应该允许一个进程访问; 2、忙则等待:临界区被访问时,其余想访问他的进程必须等待; 3、有限等待:等待的进程在外等待的...
  • 文章目录互斥(Mutual Exclusion)互斥执行机制通过共享资源进行合作通过通信进行合作 进程之间竞争资源 互斥(Mutual Exclusion) 临界区(Critical Sections) 一次只允许一个进程访问;打印机只能允许一个进程...
  • 竞争资源(临界资源) 当并发进程竞争使用同一资源时,他们之间就会发生冲突。如果操作系统将资源分配给其中的某一个进程使用,另一个进程就必须等待,直到申请的资源可用时,由操作系统分配给他们。 ...
  • 简要描述临界资源、临界区及互斥同步机制的原则 答: ①临界资源:指每次只允许一个进程访问的资源,分为硬件、软件临界资源。 ②临界区:每个进程中访问临界资源的那段程序,进程对临界区的访问必然相反,每次仅...
  • 临界资源互斥的基本方法

    千次阅读 2014-09-23 13:46:40
    在进入区设置和检查一些标志来标明是否有进程在临界区中,如果已有进程在临界区,则在进入区通过循环检查进行等待,进程离开临界区后则在退出区修改标志。 1) 算法一:单标志法。 该算法设置一个公用整型变量turn,...
  • 一看就懂,一做就会:临界资源互斥
  • 什么是临界资源?什么是临界区?题目类型:[问答题,简答题] 什么是临界资源?什么是临界区?匿名网友:参考答案: 临界资源是指一次仅允许一个进程访问的资源.临界区是指每个进程中访问临界资源的那段程序代码.试题...
  • 1、临界区:通过对多线程的串行化来访问公共资源或一段代码,速度快,适合控制数据访问。  2、互斥量:为协调共同对一个共享资源的单独访问而设计的。  3、信号量:为控制一个具有有限数量用户资源而设计。  4...
  • 虽然多个进程可以共享系统中的各种资源,但其中许多资源一次只能为一个进程所使用,我们把一次仅允许一个进程使用的资源称为临界资源。许多物理设备都属于临界资源,如打印机等。此外,还有许多变量、数据等都可以被...
  • 什么是临界资源和临界区

    万次阅读 多人点赞 2016-12-29 16:22:45
     临界资源是一次仅允许一个进程使用的共享资源。各进程采取互斥的方式,实现共享的资源称作临界资源。属于临界资源的硬件有,打印机,磁带机等;软件有消息队列,变量,数组,缓冲区等。诸进程间采取互斥方式,实现...
  • 1、临界区CriticalSection: 通过对多线程的串行化来访问公共资源或一段代码,速度快,适合控制数据访问。 2、互斥量Mutex: 为协调共同对一个共享资源的单独访问而设计的。 3、信号量Semaphore: 为控制一个具有有限...
  • 互斥(抢夺资源,间接制约)是并发执行的多个进程由于竞争同一资源而产生的相互排斥的关系。同步(直接制约)是进程间共同完成一项任务时直接发生的相互作用的关系。同步进程间具有合作关系,在执行时间上必须按...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 43,484
精华内容 17,393
关键字:

互斥的使用临界资源是通过