经典线程同步互斥问题在windows下的各种解法

最新推荐文章于 2024-06-22 13:31:35 发布
最新推荐文章于 2024-06-22 13:31:35 发布
阅读量2.3k 收藏 4
点赞数 1
分类专栏： windows 文章标签： 线程 windows

一、引言

这篇文章记录是来源于Windows多线程系列的学习笔记，表为原创，实为转载文章，只是为了让自己学的明白，稍微整理了下而已，在此向“MoreWindows”大神致敬！

二、问题所在

1.题目要求

主线程启动10个子线程并将表示子线程序号的变量地址作为参数传递给子线程。子线程接收参数 -> sleep(50) -> 全局变量++ -> sleep(0) -> 输出参数和全局变量。

要求：
1．子线程输出的线程序号不能重复。

2．全局变量的输出必须递增。

2.题目解析

分析下这个问题的考察点，主要考察点有二个：

1．主线程创建子线程并传入一个指向变量地址的指针作参数，由于线程启动须要花费一定的时间，所以在子线程根据这个指针访问并保存数据前，主线程应等待子线程保存完毕后才能改动该参数并启动下一个线程。这涉及到主线程与子线程之间的同步。

2．子线程之间会互斥的改动和输出全局变量。要求全局变量的输出必须递增。这涉及到各子线程间的互斥。

3.程序基本框架

//经典线程同步互斥问题  
#include <stdio.h>  
#include <process.h>  
#include <windows.h>  

long g_nNum; //全局资源  
unsigned int __stdcall Fun(void *pPM); //线程函数  
const int THREAD_NUM = 10; //子线程个数  

int main()  
{  
    g_nNum = 0;  
    HANDLE  handle[THREAD_NUM];  

    int i = 0;  
    while (i < THREAD_NUM)   
    {  
        handle[i] = (HANDLE)_beginthreadex(NULL, 0, Fun, &i, 0, NULL);  
        i++;//等子线程接收到参数时主线程可能改变了这个i的值  
    }  
    //保证子线程已全部运行结束  
    WaitForMultipleObjects(THREAD_NUM, handle, TRUE, INFINITE);    
    return 0;  
}  

unsigned int __stdcall Fun(void *pPM)  
{  
//由于创建线程是要一定的开销的，所以新线程并不能第一时间执行到这来  
    int nThreadNum = *(int *)pPM; //子线程获取参数  
    Sleep(50);//some work should to do  
    g_nNum++;  //处理全局资源  
    Sleep(0);//some work should to do  
    printf("线程编号为%d  全局资源值为%d\n", nThreadNum, g_nNum);  
    return 0;  
}

三、经典同步问题–关键段CS

1.关键段CRITICAL_SECTION介绍

关键段CRITICAL_SECTION一共就四个函数，使用很是方便。下面是这四个函数的原型和使用说明。

函数功能：初始化

函数原型：

void InitializeCriticalSection(LPCRITICAL_SECTIONlpCriticalSection);

函数说明：定义关键段变量后必须先初始化。

函数功能：销毁

函数原型：

void DeleteCriticalSection(LPCRITICAL_SECTIONlpCriticalSection);

函数说明：用完之后记得销毁。

函数功能：进入关键区域

函数原型：

void EnterCriticalSection(LPCRITICAL_SECTIONlpCriticalSection);

函数说明：系统保证各线程互斥的进入关键区域。

函数功能：离开关关键区域

函数原型：

void LeaveCriticalSection(LPCRITICAL_SECTIONlpCriticalSection);

2.关键段CS解决代码

#include <stdio.h>
#include <process.h>
#include <windows.h>

long g_nNum;
unsigned int __stdcall Fun(void *pPM);
const int THREAD_NUM = 10;
// 关键段变量声明
CRITICAL_SECTION g_csThreadParameter, g_csThreadCode;

int main()
{
    printf("    经典线程同步 关键段\n");
    printf("-- by MoreWindows( http://blog.csdn.net/MoreWindows ) --\n\n");

    // 关键段初始化
    InitializeCriticalSection(&g_csThreadParameter);
    InitializeCriticalSection(&g_csThreadCode);

    HANDLE handle[THREAD_NUM];
    g_nNum = 0;
    int i = 0;
    while (i < THREAD_NUM) {
        EnterCriticalSection(&g_csThreadParameter); // 进入子线程序号关键区域
        handle[i] = (HANDLE)_beginthreadex(NULL, 0, Fun, &i, 0, NULL);
        ++i;
    }

    WaitForMultipleObjects(THREAD_NUM, handle, TRUE, INFINITE);

    DeleteCriticalSection(&g_csThreadCode);
    DeleteCriticalSection(&g_csThreadParameter);
    Sleep(10000);
    return 0;
}

unsigned int __stdcall Fun(void *pPM)
{
    int nThreadNum = *(int *)pPM;
    LeaveCriticalSection(&g_csThreadParameter); // 离开字线程序号关键区域

    Sleep(50);

    EnterCriticalSection(&g_csThreadCode);  // 进入各子线程互斥区域
    g_nNum++;
    Sleep(0);
    printf("线程编号为%d 全局资源值为%d\n", nThreadNum, g_nNum);
    LeaveCriticalSection(&g_csThreadCode);
    return 0;
}

3.关键段总结

可以将关键段比作旅馆的房卡，调用EnterCriticalSection()即申请房卡，得到房卡后自己当然是可以多次进出房间的，在你调用LeaveCriticalSection()交出房卡之前，别人自然是无法进入该房间。

关键段可以用于线程间的互斥，但不可以用于同步。

最终总结下关键段的特性：

1．关键段共初始化化、销毁、进入和离开关键区域四个函数。

2．关键段可以解决线程的互斥问题，但因为具有“线程所有权”，所以无法解决同步问题。

3．推荐关键段与旋转锁配合使用。

四、经典同步问题–事件Event

1.事件Event介绍

事件Event实际上是个内核对象，它的使用非常方便。下面列出一些常用的函数。

第一个 CreateEvent

函数功能：创建事件

函数原型：

HANDLECreateEvent(

 LPSECURITY_ATTRIBUTESlpEventAttributes,

 BOOLbManualReset,

 BOOLbInitialState,

 LPCTSTRlpName

);

函数说明：

第一个参数表示安全控制，一般直接传入NULL。

第二个参数确定事件是手动置位还是自动置位，传入TRUE表示手动置位，传入FALSE表示自动置位。如果为自动置位，则对该事件调用WaitForSingleObject()后会自动调用ResetEvent()使事件变成未触发状态。打个小小比方，手动置位事件相当于教室门，教室门一旦打开（被触发），所以有人都可以进入直到老师去关上教室门（事件变成未触发）。自动置位事件就相当于医院里拍X光的房间门，门打开后只能进入一个人，这个人进去后会将门关上，其它人不能进入除非门重新被打开（事件重新被触发）。

第三个参数表示事件的初始状态，传入TRUR表示已触发。

第四个参数表示事件的名称，传入NULL表示匿名事件。

第二个 OpenEvent

函数功能：根据名称获得一个事件句柄。

函数原型：

HANDLEOpenEvent(

 DWORDdwDesiredAccess,

 BOOLbInheritHandle,

 LPCTSTRlpName     //名称

);

函数说明：

第一个参数表示访问权限，对事件一般传入EVENT_ALL_ACCESS。详细解释可以查看MSDN文档。

第二个参数表示事件句柄继承性，一般传入TRUE即可。

第三个参数表示名称，不同进程中的各线程可以通过名称来确保它们访问同一个事件。

第三个SetEvent

函数功能：触发事件

函数原型：BOOLSetEvent(HANDLEhEvent);

函数说明：每次触发后，必有一个或多个处于等待状态下的线程变成可调度状态。

第四个ResetEvent

函数功能：将事件设为末触发

函数原型：BOOLResetEvent(HANDLEhEvent);

最后一个事件的清理与销毁

由于事件是内核对象，因此使用CloseHandle()就可以完成清理与销毁了。

2.事件Event代码

#include <stdio.h>  
#include <process.h>  
#include <windows.h>  
long g_nNum;  
unsigned int __stdcall Fun(void *pPM);  
const int THREAD_NUM = 10;  
//事件与关键段  
HANDLE  g_hThreadEvent;  
CRITICAL_SECTION g_csThreadCode;  
int main()  
{  
    printf("     经典线程同步 事件Event\n");  
    printf(" -- by MoreWindows( http://blog.csdn.net/MoreWindows ) --\n\n");  
    //初始化事件和关键段 自动置位,初始无触发的匿名事件  
    g_hThreadEvent = CreateEvent(NULL, FALSE, FALSE, NULL);   
    InitializeCriticalSection(&g_csThreadCode);  

    HANDLE  handle[THREAD_NUM];   
    g_nNum = 0;  
    int i = 0;  
    while (i < THREAD_NUM)   
    {  
        handle[i] = (HANDLE)_beginthreadex(NULL, 0, Fun, &i, 0, NULL);  
        WaitForSingleObject(g_hThreadEvent, INFINITE); //等待事件被触发  
        i++;  
    }  
    WaitForMultipleObjects(THREAD_NUM, handle, TRUE, INFINITE);  

    //销毁事件和关键段  
    CloseHandle(g_hThreadEvent);  
    DeleteCriticalSection(&g_csThreadCode);  
    return 0;  
}  
unsigned int __stdcall Fun(void *pPM)  
{  
    int nThreadNum = *(int *)pPM;   
    SetEvent(g_hThreadEvent); //触发事件  

    Sleep(50);//some work should to do  

    EnterCriticalSection(&g_csThreadCode);  
    g_nNum++;  
    Sleep(0);//some work should to do  
    printf("线程编号为%d  全局资源值为%d\n", nThreadNum, g_nNum);   
    LeaveCriticalSection(&g_csThreadCode);  
    return 0;  
}

3.认识PulseEvent事件脉冲

先来看看这个函数的原形：

第五个PulseEvent

函数功能：将事件触发后立即将事件设置为未触发，相当于触发一个事件脉冲。

函数原型：BOOLPulseEvent(HANDLEhEvent);

函数说明：这是一个不常用的事件函数，此函数相当于SetEvent()后立即调用ResetEvent();此时情况可以分为两种：

1.对于手动置位事件，所有正处于等待状态下线程都变成可调度状态。

2.对于自动置位事件，所有正处于等待状态下线程只有一个变成可调度状态。

此后事件是末触发的。该函数不稳定，因为无法预知在调用PulseEvent ()时哪些线程正处于等待状态。

4.事件脉冲PulseEvent代码

#include <stdio.h>
#include <conio.h>
#include <process.h>
#include <windows.h>

HANDLE g_hThreadEvent;
// 快线程
unsigned int __stdcall FastThreadFun(void *pPM)
{
    Sleep(10); // 用这个来保证各线程调用等待函数的次序有一定的随机性
    printf("%s 启动\n", (PSTR)pPM);
    WaitForSingleObject(g_hThreadEvent, INFINITE);
    printf("%s 等到事件被触发 顺利结束\n", (PSTR)pPM);
    return 0;
}
// 慢线程
unsigned int __stdcall SlowThreadFun(void *pPM)
{
    Sleep(100);
    printf("%s 启动\n", (PSTR)pPM);
    WaitForSingleObject(g_hThreadEvent, INFINITE);
    printf("%s 等到事件被触发 顺利结束\n", (PSTR)pPM);
    return 0;
}

int main()
{
    printf("    使用PluseEvent()函数\n");
    printf(" -- by MoreWindows( http://blog.csdn.net/MoreWindows ) --\n\n");

    BOOL bManualReset = FALSE;
    // 创建事件 第二个参数手动置位TRUE, 自动置位FALSE
    g_hThreadEvent = CreateEvent(NULL, bManualReset, FALSE, NULL);
    if (bManualReset == TRUE) {
        printf("当前使用手动置位事件\n");
    } else {
        printf("当前使用自动置位事件\n");
    }

    char szFastThreadName[5][30] = {"快线程1000", "快线程1001", "快线程1002", "快线程1003", "快线程1004"};
    char szSlowThreadName[2][30] = {"慢线程196", "慢线程197"};

    int i;
    for (i = 0; i < 5; ++i) {
        _beginthreadex(NULL, 0, FastThreadFun, szFastThreadName[i], 0, NULL);
    }
    for (i = 0; i < 2; ++i) {
        _beginthreadex(NULL, 0, SlowThreadFun, szSlowThreadName[i], 0, NULL);
    }

    Sleep(50);  // 保证快线程已经全部启动
    printf("现在主线程触发一个事件脉冲 - PulseEvent()\n");
    PulseEvent(g_hThreadEvent); // 调用PulseEvent()就相当于同时调用下面二句
    // SetEvent(g_hThreadEvent);
    // ResetEvent(g_hThreadEvent);

    Sleep(3000);
    printf("时间到，主线程结束运行\n");
    CloseHandle(g_hThreadEvent);
    return 0;
}

5.事件Event总结

1．事件是内核对象，事件分为手动置位事件和自动置位事件。事件Event内部它包含一个使用计数（所有内核对象都有），一个布尔值表示是手动置位事件还是自动置位事件，另一个布尔值用来表示事件有无触发。

2．事件可以由SetEvent()来触发，由ResetEvent()来设成未触发。还可以由PulseEvent()来发出一个事件脉冲。

3．事件可以解决线程间同步问题，因此也能解决互斥问题。

五、经典同步问题–互斥量Mutex

1.互斥量Mutex简介

互斥量也是一个内核对象，它用来确保一个线程独占一个资源的访问。互斥量与关键段的行为非常相似，并且互斥量可以用于不同进程中的线程互斥访问资源。使用互斥量Mutex主要将用到四个函数：

第一个 CreateMutex

函数功能：创建互斥量（注意与事件Event的创建函数对比）

函数原型：

HANDLECreateMutex(

  LPSECURITY_ATTRIBUTESlpMutexAttributes,

  BOOLbInitialOwner,     

  LPCTSTRlpName

);

函数说明：

第一个参数表示安全控制，一般直接传入NULL。

第二个参数用来确定互斥量的初始拥有者。如果传入TRUE表示互斥量对象内部会记录创建它的线程的线程ID号并将递归计数设置为1，由于该线程ID非零，所以互斥量处于未触发状态。如果传入FALSE，那么互斥量对象内部的线程ID号将设置为NULL，递归计数设置为0，这意味互斥量不为任何线程占用，处于触发状态。

第三个参数用来设置互斥量的名称，在多个进程中的线程就是通过名称来确保它们访问的是同一个互斥量。

函数访问值：

成功返回一个表示互斥量的句柄，失败返回NULL。

第二个打开互斥量

函数原型：

HANDLEOpenMutex(

 DWORDdwDesiredAccess,

 BOOLbInheritHandle,

 LPCTSTRlpName     //名称

);

函数说明：

第一个参数表示访问权限，对互斥量一般传入MUTEX_ALL_ACCESS。详细解释可以查看MSDN文档。

第二个参数表示互斥量句柄继承性，一般传入TRUE即可。

第三个参数表示名称。某一个进程中的线程创建互斥量后，其它进程中的线程就可以通过这个函数来找到这个互斥量。

函数访问值：

成功返回一个表示互斥量的句柄，失败返回NULL。

第三个触发互斥量

函数原型：

BOOLReleaseMutex (HANDLEhMutex)

函数说明：

访问互斥资源前应该要调用等待函数，结束访问时就要调用ReleaseMutex()来表示自己已经结束访问，其它线程可以开始访问了。

最后一个清理互斥量

由于互斥量是内核对象，因此使用CloseHandle()就可以（这一点所有内核对象都一样）。

2.互斥量解决代码

与关键段类似，互斥量也是不能解决线程间的同步问题。

#include <stdio.h>
#include <process.h>
#include <windows.h>

long g_nNum;
unsigned int __stdcall Fun(void *pPM);
const int THREAD_NUM = 10;
// 互斥量与关键段
HANDLE g_hThreadParameter;
CRITICAL_SECTION g_csThreadCode;

int main()
{
    printf("    经典线程同步 互斥量Mutext\n");
    printf(" -- by MoreWindows( http://blog.csdn.net/MoreWindows ) --\n\n");

    // 初始化互斥量与关键段  第二个参数为TRUE表示互斥量为创建进程所有
    g_hThreadParameter = CreateMutex(NULL, FALSE, NULL);
    InitializeCriticalSection(&g_csThreadCode);

    HANDLE handle[THREAD_NUM];
    g_nNum = 0;
    int i = 0;
    while (i < THREAD_NUM) {
        handle[i] = (HANDLE)_beginthreadex(NULL, 0, Fun, &i, 0, NULL);
        WaitForSingleObject(g_hThreadParameter, INFINITE);  // 等待互斥量被触发
        i++;
    }
    WaitForMultipleObjects(THREAD_NUM, handle, TRUE, INFINITE);

    // 销毁互斥量和关键段
    CloseHandle(g_hThreadParameter);
    DeleteCriticalSection(&g_csThreadCode);
    for (i = 0; i < THREAD_NUM; i++) {
        CloseHandle(handle[i]);
    }
    Sleep(10000);
    return 0;
}

unsigned int __stdcall Fun(void *pPM)
{
    int nThreadNum = *(int *)pPM;
    ReleaseMutex(g_hThreadParameter);   // 触发互斥量

    Sleep(50);

    EnterCriticalSection(&g_csThreadCode);
    g_nNum++;
    Sleep(0);
    printf("线程编号为%d 全局资源值为%d\n", nThreadNum, g_nNum);
    LeaveCriticalSection(&g_csThreadCode);
    return 0;
}

3.互斥量实现两个进程间的资源互斥访问

进程1

#include <stdio.h>
#include <conio.h>
#include <windows.h>

const TCHAR MUTEXT_NAME[] = TEXT("Mutex_MoreWindows");

int main()
{
    HANDLE hMutex = CreateMutex(NULL, TRUE, MUTEXT_NAME);   // 创建互斥量
    printf("互斥量已经创建，现在按任意键触发互斥量\n");
    getch();
    // exit(0);
    ReleaseMutex(hMutex);
    printf("互斥量已经触发\n");
    CloseHandle(hMutex);
    Sleep(10000);
    return 0;
}

进程2

#include <stdio.h>
#include <windows.h>

const TCHAR MUTEX_NAME[] = TEXT("Mutex_MoreWindows");

int main()
{
    HANDLE hMutex = OpenMutex(MUTEX_ALL_ACCESS, TRUE, MUTEX_NAME);  // 打开互斥量
    if (NULL == hMutex) {
        printf("打开互斥量失败\n");
        Sleep(10000);
        return 0;
    }
    printf("等待中...\n");
    DWORD dwResult = WaitForSingleObject(hMutex, 20 * 1000);    // 等待互斥量被触发
    switch (dwResult) 
    {
    case WAIT_ABANDONED:
        printf("拥有互斥量的进程意外终止\n");
        break;

    case WAIT_OBJECT_0:
        printf("已经收到信号\n");
        break;

    case WAIT_TIMEOUT:
        printf("信号未在规定的时间内送到\n");
        break;
    }
    CloseHandle(hMutex);
    Sleep(10000);
    return 0;
}

4.互斥量Mutex总结

最后总结下互斥量Mutex：

1．互斥量是内核对象，它与关键段都有“线程所有权”所以不能用于线程的同步。

2．互斥量能够用于多个进程之间线程互斥问题，并且能完美的解决某进程意外终止所造成的“遗弃”问题。

六、经典同步问题–信号量Semaphore

1.信号量Semaphore简介

信号量Semaphore常用有三个函数，使用很方便。下面是这几个函数的原型和使用说明:
第一个 CreateSemaphore

函数功能：创建信号量

函数原型：

HANDLE CreateSemaphore(

  LPSECURITY_ATTRIBUTES lpSemaphoreAttributes,

  LONG lInitialCount,

  LONG lMaximumCount,

  LPCTSTR lpName

);

函数说明：

第一个参数表示安全控制，一般直接传入NULL。

第二个参数表示初始资源数量。

第三个参数表示最大并发数量。

第四个参数表示信号量的名称，传入NULL表示匿名信号量。

第二个 OpenSemaphore

函数功能：打开信号量

函数原型：

HANDLE OpenSemaphore(

  DWORD dwDesiredAccess,

  BOOL bInheritHandle,

  LPCTSTR lpName

);

函数说明：

第一个参数表示访问权限，对一般传入SEMAPHORE_ALL_ACCESS。详细解释可以查看MSDN文档。

第二个参数表示信号量句柄继承性，一般传入TRUE即可。

第三个参数表示名称，不同进程中的各线程可以通过名称来确保它们访问同一个信号量。

第三个 ReleaseSemaphore

函数功能：递增信号量的当前资源计数

函数原型：

BOOL ReleaseSemaphore(

  HANDLE hSemaphore,

  LONG lReleaseCount,  

  LPLONG lpPreviousCount 

);

函数说明：

第一个参数是信号量的句柄。

第二个参数表示增加个数，必须大于0且不超过最大资源数量。

第三个参数可以用来传出先前的资源计数，设为NULL表示不需要传出。

注意：当前资源数量大于0，表示信号量处于触发，等于0表示资源已经耗尽故信号量处于末触发。在对信号量调用等待函数时，等待函数会检查信号量的当前资源计数，如果大于0(即信号量处于触发状态)，减1后返回让调用线程继续执行。一个线程可以多次调用等待函数来减小信号量。

最后一个 信号量的清理与销毁

由于信号量是内核对象，因此使用CloseHandle()就可以完成清理与销毁了。

2.信号量解决代码

信号量可以解决线程之间的同步问题。

#include <stdio.h>
#include <process.h>
#include <windows.h>

long g_nNum;
unsigned int __stdcall Fun(void *pPM);
const int THREAD_NUM = 10;
// 信号量与关键段
HANDLE g_hThreadParameter;
CRITICAL_SECTION g_csThreadCode;

int main()
{
    printf("    经典线程同步 信号量Semaphore\n");
    printf(" -- by MoreWindows( http://blog.csdn.net/MoreWindows ) --\n\n");

    // 初始化信号量和关键段
    g_hThreadParameter = CreateSemaphore(NULL, 0, 1, NULL); // 当前0个资源，最大允许1个同时访问
    InitializeCriticalSection(&g_csThreadCode);

    HANDLE handle[THREAD_NUM];
    g_nNum = 0;
    int i = 0;
    while (i < THREAD_NUM) {
        handle[i] = (HANDLE)_beginthreadex(NULL, 0, Fun, &i, 0, NULL);
        WaitForSingleObject(g_hThreadParameter, INFINITE);  // 等待信号量 > 0
        ++i;
    }
    WaitForMultipleObjects(THREAD_NUM, handle, TRUE, INFINITE);

    // 销毁信号量和关键段
    DeleteCriticalSection(&g_csThreadCode);
    CloseHandle(g_hThreadParameter);
    for (i = 0; i < THREAD_NUM; i++) {
        CloseHandle(handle[i]);
    }
    Sleep(10000);
    return 0;
}

unsigned int __stdcall Fun(void *pPM)
{
    int nThreadNum = *(int *)pPM;
    ReleaseSemaphore(g_hThreadParameter, 1, NULL);  // 信号量++

    Sleep(50);

    EnterCriticalSection(&g_csThreadCode);
    ++g_nNum;
    Sleep(0);
    printf("线程编号为%d 全局资源值为%d\n", nThreadNum, g_nNum);
    LeaveCriticalSection(&g_csThreadCode);
    return 0;
}

3.信号量Semaphore总结

由于信号量可以计算资源当前剩余量并根据当前剩余量与零比较来决定信号量是处于触发状态或是未触发状态，因此信号量的应用范围相当广泛。

13.[个人]C++线程入门到进阶（13）----多线程同步内功心法--PV操作（上）
shuimanting520的博客
04-25 1282
上面的文章讲解了在Windows系统下实现多线程同步互斥的方法，为了提高在实际问题中分析和思考多个线程之间同步互斥问题的能力，接下来将讲解PV操作，这也是操作系统中的重点和难点。本文将会先简要介绍下PV操作的来源和基本使用方法，然后再通过两道经典的计算机考研真题——放水果和安全岛来示范如何运用PV操作。 先讲讲PV操作的起源和用法。 1962年，荷兰学者Dijksrta在参与X8计算机
进程、线程和协程详解
十分甜咖啡
07-26 2555
进程、线程和协程
操作系统 4种经典同步互斥问题
06-10
操作系统中4类经典同步问题实验。Windows下，包括4个C++代码：生产者与消费者 、读者和写者 、哲学家问题 、理发师问题和1份实验报告
windows多线程（五） 互斥量 Mutex
一
04-16 4692
一、互斥量 互斥量是windows的一个内核对象，互斥量与关键段的作用相似，可以用来确保全局资源的互斥访问。并且互斥量可以用在不同的进程中的线程互斥访问全局资源。 二、相关函数说明 使用互斥量Mutex主要用到以下四个函数，下面将介绍这四个函数。 （一） 创建互斥量 1. 函数原型 HANDLE CreateMutex( LPSECURITY_ATTRIBUTESlpMute...
操作系统–经典进程同步与互斥问题
最新发布
m0_74242327的博客
06-22 376
我以下所写的算法都是基于我所学习的书籍《计算机操作系统–第4版》的第84页 所写。
经典进程同步和互斥问题
长期更新自学笔记
05-26 2091
基本概念 进程同步： 对多个进程在执行次序上进行协调，使并发执行的各进程间能按照一定的规则共享系统资源，以免进程无序争夺资源而导致系统混乱。 进程互斥： 某一时刻不允许多个进程同时访问临界资源，只能单个进程访问 一、生产者消费者问题 在此问题中，需要注意以下几点： 只有缓冲区没满时，生产者才能把产品放入缓冲区，否则必须等待 只有缓冲区不空时，消费者才能从缓冲区取出产品，否则必须等待 缓冲区属于临界资源，各进程必须互斥地进行访问 那么如何用P、V操作实现这些要求呢？ 我们以2个生产者、3个消费者，缓
【线程进程】互斥的问题
不分解的单应矩阵
05-15 729
1、同一进程中线程之间的局部变量不会相互影响，不需互斥；对于成员变量由于是共享的，所以只要改变就需要互斥 2、不同进程之间的变量不一样，互不影响，不需要互斥 故需要互斥的有p1的x+=1与x+=2，以及p2中的x+=3与x+=4 ...
Windows多线程的同步与互斥
luxiaoxun的专栏
06-06 3984
系统中的所有线程都必须拥有对各种系统资源的访问权，这些资源包括内存堆栈，串口，文件，窗口和许多其他资源。如果一个线程需要独占对资源的访问权，那么其他线程就无法完成它们的工作。反过来说，也不能让任何一个线程在任何时间都能访问所有的资源。如果在一个线程从内存块中读取数据时，另一个线程却想要将数据写入同一个内存块，那么这就像你在读一本书时另一个人却在修改书中的内容一样。这样，书中的内容就会被搞得乱七八糟
操作系统中进程/线程模型
weixin_39754631的博客
06-05 1031
进程与线程1 进程/线程模型进程的定义引入线程机制的动机和思路线程的定义线程和进程的区别2 进程状态切换java中线程的状态及状态转换 1 进程/线程模型 进程的定义 进程：进程是具有独立功能的程序关于某个数据集合的一次执行过程，也是操作系统进行资源分配和保护的基本单位。 程序的一次执行过程，一个程序执行了多次是不同的进程 是正在运行程序的抽象，进程是对CPU的抽象 将一个物理上的CPU虚拟为多...
操作系统中的哲学家就餐问题
03-19
哲学家就餐问题是计算机科学领域内一个经典的进程同步问题，常被用来说明死锁、饥饿等并发控制问题。该问题最早由Edsger Dijkstra在1965年提出。问题设定为：五位哲学家围坐在一张圆桌周围，桌上放有五个碗和五双...
现代操作系统（一）：进程与线程
weixin_48922154的博客
07-15 836
文章目录一、进程用户态和内核态1. 进程模型2. 进程的创建3. 进程的终止4. 进程的层次结构5. 进程的状态6. 进程的实现二、线程1. 线程的使用2. 线程模型1. POSIX线程2. 实现线程 一、进程 用户态和内核态 多数操作系统有两种运行模式：用户态和内核态 内核态： 这个状态下，操作系统具有对所有硬件的完全访问权，可以执行及其能够运行的任何指令 表示一个应用进程执行系统调用后，或 I/O 中断、时钟中断后，进程便处于核心态执行。 运行在内核态的程序可以访问的资源多，但可靠性、安全性要求高，维
编程实现进程（线程）同步和互斥
11-25
在Windows等操作系统下，使用的VC、VB、java或C等编程语言，采用进程（线程）同步和互斥的技术编写程序实现生产者-消费者问题或哲学家进餐问题或读者-写者问题或自己设计一个简单进程（线程）同步和互斥的实际问题。
进程线程互斥同步方法
02-28
进程，线程同步互斥的控制方法，详细介绍，个人总结，面试常问
Java中的线程互斥问题
The magic of fingertips
03-21 829
有如下代码： public class TraditionalThreadSynchronized { public static void main(String[] args) { new TraditionalThreadSynchronized().init(); } public void init() { final Outputer outputer = new
线程-------互斥
qq_57283958的博客
05-11 999
进程线程间的互斥相关背景概念 临界资源：多线程执行流共享的资源就叫做临界资源 临界区：每个线程内部，访问临界资源的代码，就叫做临界区 互斥：任何时刻，互斥保证有且只有一个执行流进入临界区，访问临界资源，通常对临界资源起保护作用 原子性（后面讨论如何实现）：不会被任何调度机制打断的操作，该操作只有两态，要么完成，要么未完成 同步：一般而言，让访问临界资源的过程在安全的前提下（一般都是互斥和原子的），让访问资源具有一定的顺序性（具有合理性） 互斥量mutex 大部分情况，线程使用的
多线程互斥问题
weixin_34257076的博客
10-26 120
采用pthread_create建立一个新线程，与fork方式建立新进程不同（尽管在Linux环境下进程与线程具有相同概念）。所有pthread将会共用主线程中的所有变量，而不是如fork方式仅仅将所有变量引用加1。由于pthread共用问题的存在，将会引发在Linux下多线程编程的互斥问题。测试如下： 代码示例： 1 #include <stdio.h> 2 #incl...
java线程互斥问题_多线程互斥问题
weixin_39793189的博客
02-17 141
采用pthread_create建立一个新线程，与fork方式建立新进程不同(尽管在Linux环境下进程与线程具有相同概念)。所有pthread将会共用主线程中的所有变量，而不是如fork方式仅仅将所有变量引用加1。由于pthread共用问题的存在，将会引发在Linux下多线程编程的互斥问题。测试如下：代码示例：1 #include 2 #include 3 #include 45 int cou...
windows 多线程 同步与互斥
lanwanjunxixihaha的专栏
12-10 509
此代码参考博客：http://blog.csdn.net/morewindows/article/details/7442333 秒杀多线程第四篇 一个经典的多线程同步问题 //win 多线程 #define THREAD_NUM 10 int threadCount=0; int threadNO=0; //用于互斥 CRITICAL_SECTION NOCritical
windows多线程同步互斥--总结
weixin_33910137的博客
07-21 152
2019独角兽企业重金招聘Python工程师标准>>> ...
Python线程同步互斥与死锁解析
"本文主要探讨了Python线程中的同步互斥和死锁问题，通过示例代码详细解释了相关概念，旨在帮助读者理解和掌握线程间的通信与协作机制。" 在多线程编程中，线程同步互斥是确保线程安全、避免数据竞争的关键。在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值