• 操作系统 多线程访问共享资源产生的问题

    首先我们假设一种情况  创建了10个线程  这些线程都执行一个线程函数 (都做一个事)

    如  我们设置了是个窗口 每个窗口都负责买火车票  我们的火车票的总数为100

    卖完为止  

    我们定义了一个全局变量

    long ticket=100; 为票数

    每卖出一张票  票数--

    这里我们需要创建了10个线程  这些线程都执行一个线程函数 (买票)

    但是 在多个线程同时访问一个共享资源时  会产生并发问题 

    如:  多个线程同时卖同一张票

    那么为了解决并发问题  我么的

    解决方案:线程同步

    线程同步方式:

    1.原子访问:同一时间 只允许一个线程访问资源 volatile防止编译优化,对特殊地址的稳定访问.  直接对内存进行操作

    这里想对票数--  可以用

    InterlockedDecrement(&ticket);  他会对票数--  直接对内存进行操作

    同时避免进程并行问题

    CRITICAL_SECTION m_cs;

    2.临界区(关键段)(用户模式下的线程同步 ):同一时刻只允许一个进程访问代码段

    分为:

    (1)直接阻塞:如果已经有线程在执行代码段  他就会等待  直到那个线程执行完代码后  锁会随机分配给一个等待的进程

    主函数中:

    1. //初始化关键段
    2.     //InitializeCriticalSection(&m_cs);

    线程函数中:

    1. EnterCriticalSection(&m_cs);
    2. if(ticket==0)
    3.         {
    4.             printf("Thread id[%d] go-------\n",GetCurrentThreadId());
    5.  
    6.  
    7.             
    8.  
    9.             
    10.             LeaveCriticalSection(&m_cs);
    11.             
    12.             break;
    13.         }
    14.         ticket--;
    15.         printf("Thread id[%d] ticket %d\n",GetCurrentThreadId(),ticket);
    16.  
    17.         锁的出口
    18.         LeaveCriticalSection(&m_cs);
    19.

    (2)旋转锁:如果已经有线程在执行代码段  他会等待一定的时间(由我们自己决定)  如果等待时间到了  代码段其他线程还是    没执行完  他就会走  不继续等待

    这里不好测试  不直观  就不进行演示

    (3)非阻塞:如果已经有线程在执行代码段 他就会走  不继续等待

    主函数中:

    1. //初始化关键段
    2.     //InitializeCriticalSection(&m_cs);

    线程函数中:

    1.   while(1)
    2.         {
    3.         if(ticket==0)
    4.         {
    5.             printf("Thread id[%d] go\n",GetCurrentThreadId());
    6.             break;
    7.  
    8.         }
    9.  
    10.         Sleep(10);
    11.  
    12.  
    13.        
    14.  
    15.         if(!TryEnterCriticalSection(&m_cs))
    16.             continue;//走开
    17.  
    18.  
    19.         //EnterCriticalSection(&m_cs);
    20.  
    21.         
    22.  
    23.        
    24.         if(ticket==0)
    25.         {
    26.             printf("Thread id[%d] go-------\n",GetCurrentThreadId());
    27.  
    28.  
    29.             
    30.  
    31.             
    32.             LeaveCriticalSection(&m_cs);
    33.             
    34.             break;
    35.         }
    36.         ticket--;
    37.         printf("Thread id[%d] ticket %d\n",GetCurrentThreadId(),ticket);
    38.  
    39.         
    40.         LeaveCriticalSection(&m_cs);
    41.  
    42.        
    43.  
    44.     }
    45.     return 0;

    线程函数完整代码如下

    1. DWORD WINAPI ThreadProc(LPVOID lpParameter)
    2. {
    3.     while(1)
    4.         {
    5.         if(ticket==0)
    6.         {
    7.             printf("Thread id[%d] go\n",GetCurrentThreadId());
    8.             break;
    9.  
    10.         }
    11.  
    12.         Sleep(10);
    13.  
    14.  
    15.         //原子访问
    16.         //InterlockedDecrement(&ticket);//对共享资源执行--操作
    17.  
    18.         //锁的入口   只允许一个进程访问下列关键段
    19.  
    20.         //if(!TryEnterCriticalSection(&m_cs))//
    21.             //continue;//走开
    22.  
    23.  
    24.         //EnterCriticalSection(&m_cs);
    25.  
    26.         //事件的判断  看有没有信号  没信号就走
    27.         if(WAIT_TIMEOUT==WaitForSingleObject(m_hSemaphore,10))
    28.  
    29.         {
    30.                 continue;
    31.  
    32.         }
    33.  
    34.  
    35.  
    36.         //WaitForSingleObject(m_hMutex,INFINITE);
    37.         if(ticket==0)
    38.         {
    39.             printf("Thread id[%d] go-------\n",GetCurrentThreadId());
    40.  
    41.  
    42.             //SetEvent(m_hEvent);
    43.  
    44.             //ReleaseMutex(m_hMutex);
    45.             //LeaveCriticalSection(&m_cs);
    46.             ReleaseSemaphore(m_hSemaphore,1,NULL);
    47.             break;
    48.         }
    49.         ticket--;
    50.         printf("Thread id[%d] ticket %d\n",GetCurrentThreadId(),ticket);
    51.  
    52.         //锁的出口
    53.         //LeaveCriticalSection(&m_cs);
    54.  
    55.         //信号量
    56.         ReleaseSemaphore(m_hSemaphore,1,NULL);
    57.  
    58.         //事件
    59.         //SetEvent(m_hEvent);
    60.  
    61.         //互斥量
    62.         //ReleaseMutex(m_hMutex);
    63.  
    64.     }
    65.     return 0;
    66.  
    67. }

    3.内核对象:同一时刻只允许一个线程访问代码段

    (1)互斥量:一直等互斥量  直到等到为止  执行代码

    1. //初始化互斥量
    2.    //m_hMutex=CreateMutex(0,//安全属性
    3.    //                     1,//初始拥有权
    4.    //                     L"MyMutex"//名字
    5.    //                     );
    6.    //ReleaseMutex(m_hMutex);

    1. DWORD WINAPI ThreadProc(LPVOID lpParameter)
    2. {
    3.     while(1)
    4.         {
    5.         if(ticket==0)
    6.         {
    7.             printf("Thread id[%d] go\n",GetCurrentThreadId());
    8.             break;
    9.  
    10.         }
    11.  
    12.         Sleep(10);
    13.  
    14.  
    15.         
    16.  
    17.  
    18.         WaitForSingleObject(m_hMutex,INFINITE);
    19.         if(ticket==0)
    20.         {
    21.             printf("Thread id[%d] go-------\n",GetCurrentThreadId());
    22.  
    23.  
    24.             
    25.  
    26.             ReleaseMutex(m_hMutex);
    27.            
    28.             break;
    29.         }
    30.         ticket--;
    31.         printf("Thread id[%d] ticket %d\n",GetCurrentThreadId(),ticket);
    32.  
    33.        
    34.         //互斥量
    35.         ReleaseMutex(m_hMutex);
    36.  
    37.     }
    38.     return 0;
    39.  
    40. }

    (2)事件  分配事件信号 谁 抢到谁执行

    1. //初始化事件
    2.     //m_hEvent=CreateEventA(0,0,0,0);
    3.     //SetEvent(m_hEvent);//初始信号为0  把信号设置为1  让线程去抢

    1.  while(1)
    2.         {
    3.         if(ticket==0)
    4.         {
    5.             printf("Thread id[%d] go\n",GetCurrentThreadId());
    6.             break;
    7.  
    8.         }
    9.  
    10.         Sleep(10);
    11.  
    12.  
    13.         
    14.         //事件的判断  看有没有信号  没信号就走
    15.         if(WAIT_TIMEOUT==WaitForSingleObject(m_hEvent,10))
    16.  
    17.         {
    18.                 continue;
    19.  
    20.         }
    21.  
    22.  
    23.  
    24.         
    25.         if(ticket==0)
    26.         {
    27.             printf("Thread id[%d] go-------\n",GetCurrentThreadId());
    28.  
    29.  
    30.             SetEvent(m_hEvent);
    31.  
    32.             
    33.             break;
    34.         }
    35.         ticket--;
    36.         printf("Thread id[%d] ticket %d\n",GetCurrentThreadId(),ticket);
    37.  
    38.  
    39.         //事件
    40.         SetEvent(m_hEvent);
    41.  
    42.         
    43.     }
    44.     return 0;

    (3)信号量:允许同一时间内指定数量的线程访问代码段

    1. //初始化信号量
    2.     m_hSemaphore=CreateSemaphoreW(0,//安全属性
    3.                                  1,//初始化信号量总数
    4.                                  10,//最大信号量总数
    5.                                  0//名字
    6.                                  );

    1. DWORD WINAPI ThreadProc(LPVOID lpParameter)
    2. {
    3.     while(1)
    4.         {
    5.         if(ticket==0)
    6.         {
    7.             printf("Thread id[%d] go\n",GetCurrentThreadId());
    8.             break;
    9.  
    10.         }
    11.  
    12.         Sleep(10);
    13.  
    14.  
    15.        
    16.  
    17.  
    18.        
    19.  
    20.         //信号的判断  看有没有信号  没信号就走
    21.         if(WAIT_TIMEOUT==WaitForSingleObject(m_hSemaphore,10))
    22.  
    23.         {
    24.                 continue;
    25.  
    26.         }
    27.  
    28.  
    29.  
    30.         
    31.         if(ticket==0)
    32.         {
    33.             printf("Thread id[%d] go-------\n",GetCurrentThreadId());
    34.  
    35.  
    36.             
    37.             ReleaseSemaphore(m_hSemaphore,1,NULL);
    38.             break;
    39.         }
    40.         ticket--;
    41.         printf("Thread id[%d] ticket %d\n",GetCurrentThreadId(),ticket);
    42.  
    43.       
    44.         //信号量
    45.         ReleaseSemaphore(m_hSemaphore,1,NULL);
    46.  
    47.         
    48.  
    49.     }
    50.     return 0;
    51.  
    52. }

    上述三种内核对象需要在最后句柄释放

    1. if(m_hMutex)
    2.     {
    3.         CloseHandle(m_hMutex);
    4.         m_hMutex=0;
    5.     }
    6.     if(m_hEvent)
    7.     {
    8.         CloseHandle(m_hEvent);
    9.         m_hEvent=0;
    10.     }
    11.     if(m_hSemaphore)
    12.     {
    13.         CloseHandle(m_hSemaphore);
    14.         m_hSemaphore=0;
    15.     }

    我们在这里实现了单例模式

    1. //单例
    2.     HANDLE hdl=OpenMutexW(MUTEX_ALL_ACCESS,0,L"MyMutex");
    3.     if(hdl)
    4.     {
    5.         qDebug()<<"app is exists";
    6.         exit(0);
    7.     }

    完整代码如下

    1. #include 
    2. #include 
    3. #include
    4.  
    5. long ticket=100;
    6. CRITICAL_SECTION m_cs;// 临街
    7. HANDLE m_hMutex;//互斥量
    8. HANDLE m_hEvent;//事件
    9. HANDLE m_hSemaphore;//信号量
    10.  
    11. DWORD WINAPI ThreadProc(LPVOID lpParameter)
    12. {
    13.     while(1)
    14.         {
    15.         if(ticket==0)
    16.         {
    17.             printf("Thread id[%d] go\n",GetCurrentThreadId());
    18.             break;
    19.  
    20.         }
    21.  
    22.         Sleep(10);
    23.  
    24.  
    25.         //原子访问
    26.         //InterlockedDecrement(&ticket);//对共享资源执行--操作
    27.  
    28.         //锁的入口   只允许一个进程访问下列关键段
    29.  
    30.         //if(!TryEnterCriticalSection(&m_cs))//
    31.             //continue;//走开
    32.  
    33.  
    34.         //EnterCriticalSection(&m_cs);
    35.  
    36.         //事件的判断  看有没有信号  没信号就走
    37.         if(WAIT_TIMEOUT==WaitForSingleObject(m_hSemaphore,10))
    38.  
    39.         {
    40.                 continue;
    41.  
    42.         }
    43.  
    44.  
    45.  
    46.         //WaitForSingleObject(m_hMutex,INFINITE);
    47.         if(ticket==0)
    48.         {
    49.             printf("Thread id[%d] go-------\n",GetCurrentThreadId());
    50.  
    51.  
    52.             //SetEvent(m_hEvent);
    53.  
    54.             //ReleaseMutex(m_hMutex);
    55.             //LeaveCriticalSection(&m_cs);
    56.             ReleaseSemaphore(m_hSemaphore,1,NULL);
    57.             break;
    58.         }
    59.         ticket--;
    60.         printf("Thread id[%d] ticket %d\n",GetCurrentThreadId(),ticket);
    61.  
    62.         //锁的出口
    63.         //LeaveCriticalSection(&m_cs);
    64.  
    65.         //信号量
    66.         ReleaseSemaphore(m_hSemaphore,1,NULL);
    67.  
    68.         //事件
    69.         //SetEvent(m_hEvent);
    70.  
    71.         //互斥量
    72.         //ReleaseMutex(m_hMutex);
    73.  
    74.     }
    75.     return 0;
    76.  
    77. }
    78. int main(int argc, char *argv[])
    79. {
    80.     QCoreApplication a(argc, argv);
    81.  
    82.     //单例
    83.     HANDLE hdl=OpenMutexW(MUTEX_ALL_ACCESS,0,L"MyMutex");
    84.     if(hdl)
    85.     {
    86.         qDebug()<<"app is exists";
    87.         exit(0);
    88.     }
    89.  
    90.     //初始化信号量
    91.     m_hSemaphore=CreateSemaphoreW(0,//安全属性
    92.                                  1,//初始化信号量总数
    93.                                  10,//最大信号量总数
    94.                                  0//名字
    95.                                  );
    96.  
    97.  
    98.     //初始化事件
    99.     //m_hEvent=CreateEventA(0,0,0,0);
    100.     //SetEvent(m_hEvent);//初始信号为0  把信号设置为1  让线程去抢
    101.  
    102.  
    103.     //初始化关键段
    104.     //InitializeCriticalSection(&m_cs);
    105.  
    106.  
    107.     //初始化互斥量
    108.    //m_hMutex=CreateMutex(0,//安全属性
    109.    //                     1,//初始拥有权
    110.    //                     L"MyMutex"//名字
    111.    //                     );
    112.    //ReleaseMutex(m_hMutex);
    113.  
    114.  
    115.     HANDLE han=NULL;
    116.     for(int  i=0;i<10;i++)
    117.     {
    118.           han=CreateThread(0,0,&ThreadProc,0,0,0);
    119.           if(han)
    120.           {
    121.                   CloseHandle(han);
    122.                   han=0;
    123.  
    124.           }
    125.     }
    126.  
    127.  
    128.     a.exec();
    129.     //销毁关键段
    130.     //DeleteCriticalSection(&m_cs);
    131.  
    132.     //释放内核对象  互斥量/事件
    133.     if(m_hMutex)
    134.     {
    135.         CloseHandle(m_hMutex);
    136.         m_hMutex=0;
    137.     }
    138.     if(m_hEvent)
    139.     {
    140.         CloseHandle(m_hEvent);
    141.         m_hEvent=0;
    142.     }
    143.     if(m_hSemaphore)
    144.     {
    145.         CloseHandle(m_hSemaphore);
    146.         m_hSemaphore=0;
    147.     }
    148.     return a.exec();
    149. }

  • 相关阅读:
    VScode配置Jupyter
    【信息学CSP-J近16年历年真题64题】真题练习与解析 第9题之数字游戏
    C++ 反汇编 - 关于函数调用约定
    动态规划算法
    sql优化常用的几种方法
    php对接飞书机器人
    点云处理开发测试题目 实现2
    网易数帆自主创新再获认可：轻舟微服务入选信创技术图谱
    【3】c++11新特性（稳定性和兼容性）—＞类成员的快速初始化
    Solidity之变量数据存储和作用域
  • 原文地址：https://blog.csdn.net/van9527/article/details/126192300