程序片段(01):01.一对一模式.c+02.中介者模式.c+03.广播模式.c

内容概要:事件

  1. ///01.一对一模式.c
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <Windows.h>
  6. //01.关于多线程:
  7. //  (临界区+互斥量):线程冲突
  8. //  (事件):线程通信
  9. //  (时间):同步线程
  10. HANDLE eventArrA[2] = { 0 };
  11. HANDLE threadArrA[2] = { 0 };
  13. DWORD WINAPI haiHua(void * p)
  14. {
  15.     printf("海华第01次说:i love you fangFang, please help me debug! \n");//信息通信内容
  16.     Sleep(1000);//信息传递时间
  17.     SetEvent(eventArrA[0]);//提示信息传到
  18.     int i = 1;
  19.     while (++i)
  20.     {
  21.         WaitForSingleObject(eventArrA[1], INFINITE);//等待信息传到
  22.         printf("海华第%02d次说:i love you fangFang, please help me debug! \n", i);
  23.         Sleep(1000);
  24.         //ResetEvent(eventArrA[1]);//重置信息提示(手动)
  25.         SetEvent(eventArrA[0]);
  26.     }
  28.     return 0;
  29. }
  31. DWORD WINAPI fangFang(void * p)
  32. {
  33.     int i = 0;
  34.     while (++i)
  35.     {
  36.         WaitForSingleObject(eventArrA[0], INFINITE);
  37.         printf("王芳第%02d次说:sorry! but i love you! \n", i);
  38.         Sleep(1000);
  39.         SetEvent(eventArrA[1]);
  40.     }
  41.     return 0;
  42. }
  44. //02.关于CreateEvent(arg1, arg2, arg3, arg4);
  45. //  arg1:安全属性集---->通常用NULL
  46. //  arg2:手动重置事件-->手动:TRUE|自动:FALSE
  47. //      注:使用一次事件通知,用TRUE,使用多次事件通知,用FALSE
  48. //      注:使用一次线程通信,通常用的是信号量机制,而不是事件机制
  49. //  arg3:事件激活状态-->通常用FALSE
  50. //  arg4:事件唯一名称-->自定义(便于检索指定事件)
  51. int main01(void)
  52. {
  53.     eventArrA[0] = CreateEvent(NULL, FALSE, FALSE, NULL);
  54.     eventArrA[1] = CreateEvent(NULL, FALSE, FALSE, NULL);
  55.     threadArrA[0] = CreateThread(NULL, 0, haiHua, NULL, 0, NULL);
  56.     threadArrA[1] = CreateThread(NULL, 0, fangFang, NULL, 0, NULL);
  57.     WaitForMultipleObjects(2, threadArrA, TRUE, INFINITE);//维持多线程异步并发执行的状态
  59.     system("");
  60. }
  62. //01.事件深入:
  63. //  1.事件用于线程通信
  64. //  2.事件的额外细节:三个案例
  65. //      双方通话---->三方通话---->一对多模式
  66. //      (相亲)            (媒婆)中介者     (广播)广播模式
  67. //02.了解一些问题:
  68. //  (临界区+互斥+原子变量):线程冲突
  69. //  事件:线程通信
  70. //  时间:同步线程
  71. //03.什么是死锁?
  72. //  编写事件的时候最容易遇到死锁的事情!
  73. //04.现在我们需要几个信号量,而且这个信号量我们用什么来进行描述?
  74. //  时间通知+信号量
  75. //05.顺序不严密:
  76. //  1.等待信号之后,信号需要复原才行,否则会出现不正常的情况(信号错乱!)
  77. //  2.信号不同步和乱序的解决方案-收到信号之后进行复位
  78. //      (1).信号复位情况--必须复位,某些情况之下自动复位,建议主动复位
  79. //      (2).围绕信号:的False&TRUE的分别
  80. //          第二个参数:密切相关-自动&手动[复位情况]
  1. ///02.中介者模式.c
  2. #define _CRT_SECURE_NO_WARNINGS
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <Windows.h>
  7. HANDLE threadArrB[3] = { 0 };
  8. HANDLE eventArrB[4] = { 0 };
  10. char strB[256] = { 0 };//线程通信内容
  12. //01.三方通话:中介者设计模式
  13. //  海华向中介者:发出事件通知0
  14. //      中介者等海华:等待事件通知0
  15. //  中介者向芳芳:发出事件通知1
  16. //      芳芳等中介者:等待事件通知1
  17. //  芳芳向中介者:发出事件通知2
  18. //      中介者等芳芳:等待事件通知2
  19. //  中介者向海华:发出事件通知3
  20. //      海华等中介者:等待事件通知3
  21. //  海华向中介者:发出事件通知0
  22. DWORD WINAPI haiHuaB(void * p)
  23. {
  24.     sprintf(strB, "海华第01次说:i love you fangFang, please help me debug! \n");//发出通信内容
  25.     Sleep(1000);//模拟通信时间
  26.     SetEvent(eventArrB[0]);//提示通信到达
  27.     int i = 1;
  28.     while (++i)
  29.     {
  30.         WaitForSingleObject(eventArrB[3], INFINITE);
  31.         memset(strB, '\0', 256);
  32.         sprintf(strB, "海华第%02d次说:i love you fangFang, please help me debug! \n", i);
  33.         Sleep(1000);
  34.         SetEvent(eventArrB[0]);
  35.     }
  36.     return 0;
  37. }
  39. DWORD WINAPI ruiFuB(void * p)
  40. {
  41.     int i = 0;
  42.     int status = 0;//切换通信对象
  43.     while (++i)
  44.     {
  45.         if (!status)
  46.         {
  47.             WaitForSingleObject(eventArrB[0], INFINITE);
  48.             printf("媒婆传递海华通信内容(传递次数:%02d): \n", i);
  49.             printf("\t%s \n", strB);
  50.             Sleep(1000);
  51.             SetEvent(eventArrB[1]);
  52.             status = 1;
  53.         }
  54.         else
  55.         {
  56.             WaitForSingleObject(eventArrB[2], INFINITE);
  57.             printf("媒婆传递芳芳通信内容(传递次数:%02d): \n", i);
  58.             printf("\t%s \n", strB);
  59.             Sleep(1000);
  60.             SetEvent(eventArrB[3]);
  61.             status = 0;
  62.         }
  63.     }
  64.     return 0;
  65. }
  67. DWORD WINAPI fangFangB(void * p)
  68. {
  69.     int i = 0;
  70.     while (++i)
  71.     {
  72.         WaitForSingleObject(eventArrB[1], INFINITE);
  73.         memset(strB, '\0', 256);
  74.         sprintf(strB, "王芳第%02d次说:sorry! but i love you! \n", i);
  75.         Sleep(1000);
  76.         SetEvent(eventArrB[2]);
  77.     }
  78.     return 0;
  79. }
  81. int main02(void)
  82. {
  83.     eventArrB[0] = CreateEvent(NULL, FALSE, FALSE, L"haiHua");
  84.     eventArrB[1] = CreateEvent(NULL, FALSE, FALSE, L"ruiFuToFang");
  85.     eventArrB[2] = CreateEvent(NULL, FALSE, FALSE, L"fangFang");
  86.     eventArrB[3] = CreateEvent(NULL, FALSE, FALSE, L"ruiFuToHua");
  87.     threadArrB[0] = CreateThread(NULL, 0, haiHuaB, NULL, 0, NULL);
  88.     threadArrB[1] = CreateThread(NULL, 0, ruiFuB, NULL, 0, NULL);
  89.     threadArrB[2] = CreateThread(NULL, 0, fangFangB, NULL, 0, NULL);
  90.     WaitForMultipleObjects(3, threadArrB, TRUE, INFINITE);
  92.     system("pause");
  93. }
  95. //01.中介者模式&广播模式&图论模式[多对多]
  96. //  中介者:三方
  97. //  广播:一对多
  98. //  图论:多对多
  99. //注:多线程这块儿必须要会树和图
  100. //02.一对多的情况下:
  101. //  既可以采用数组进行管理也可以采用链表进行管理
  102. //03.涉及到树的情况之下:
  103. //  QQ群聊天儿多线程,练就数据结构
  104. //04.一对多&多对多:
  105. //  群聊原理:中介者-->每个人进行转发
  106. //  中介者进行转发原理-->数组管理-->数组广播-->群聊模式
  107. //05.流程梳理:
  108. //  1.我发送一条消息,中介者收到之后,他进行群发动作
  109. //  2.中介者的衍生模式-->形成闭环-->选好起始点
  110. //06.编程思想:精髓
  111. //  原则上一个消息全局变量读取特点
  112. // 相当于是一个公告栏,权限读取
  113. //07.操作:
  114. //      定义全局变量,便于读取全局变量的数据
  1. ///03.广播模式.c
  2. #define _CRT_SECURE_NO_WARNINGS
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <Windows.h>
  7. HANDLE threadArrC[10] = { 0 };
  8. HANDLE eventArrC[1] = { 0 };
  10. char strC[256] = { 0 };//线程通信内容
  11. char chrArr[10] = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'J', 'K' };//代表十个人
  13. //01.一个线程发出事件通知消息,多条线程监听该事件通知消息
  14. //  一对多的模式
  15. DWORD WINAPI haiHuaC(void * p)
  16. {
  17.     char * pChr = (char *)p;
  18.     printf("i am %c haiHua's gir friend! \n", *pChr);
  19.     if ('A' == *pChr)
  20.     {
  21.         MessageBox(0, TEXT("1"), TEXT("1"), 0);//暂停通知线程
  22.         sprintf(strC, "海华女友%c speak:xiaohuahua lovely! \n", *pChr);//消息通知内容
  23.         SetEvent(eventArrC[0]);//发出事件通知
  24.         MessageBox(0, TEXT("1"), TEXT("1"), 0);//暂停通知线程
  25.         sprintf(strC, "海华女友%c speak:xiaohuahua lovely! \n", *pChr);//消息通知内容
  26.         SetEvent(eventArrC[0]);//发出事件通知
  27.     }
  28.     int i = 0;
  29.     while (++i)
  30.     {
  31.         WaitForSingleObject(eventArrC[0], INFINITE);//等待事件通知
  32.         printf("haiHua's girl friend %c read %s! \n", pChr, strC);
  33.         Sleep(1000);
  34.         ResetEvent(eventArrC[0]);
  35.     }
  37.     return 0;
  38. }
  40. int main03(void)
  41. {
  42.     eventArrC[0] = CreateEvent(NULL, TRUE, FALSE, NULL);
  43.     for (int i = 0; i < 10; ++i)
  44.     {
  45.         threadArrC[i] = CreateThread(NULL, 0, haiHuaC, &chrArr[i], 0, NULL);
  46.     }
  47.     WaitForMultipleObjects(10, threadArrC, TRUE, INFINITE);
  49.     system("pause");
  50. }
  52. //01.中介者设计模式之广播模式:QQ群聊原理
  53. //  群聊-->数组-->链表-->环状-->局域网:环状结构[网络可靠性]
  54. //02.QQ的开发:不仅有发送和收取消息-->所以线程非常多
  55. //  信号对称-->需要进行手动进行事件的设置
  56. //      一对一:自动
  57. //      中介者:自动
  58. //      一对多:手动
  59. //      多对多:手动

程序片段(02):01.Semaphore.c+02.SemaphoreNew.c

内容概要:信号量

  1. ///01.Semaphore.c
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <Windows.h>
  6. //01.信号量:
  7. //  1.类似于空位的特点:
  8. //  2.空置多少个位置就可以容纳多少个并行线程执行
  9. //注:当空余的位置为0的时候,也就不能在另起线程执行任务了
  10. #define id L"haiHua"//信号ID
  11. #define MAX 3//空位数
  13. //02.多线程信号量(semaphore)通信:
  14. //  1.特点:打开一个信号量(等同于检索一个指定ID名称的信号量)
  15. //  2.格式:HANDLE mySema = OpenSemaphore(arg1, arg2, arg3);
  16. //      arg1:信号量检索范围(SEMAPHORE_ALL_ACCESS)
  17. //      arg2:继承特性
  18. //      arg3:信号量检索名称(自定义名称,在固定范围内唯一标识信号量)
  19. //  3.刚打开信号量的时候:
  20. //      信号量的空位为0,也就是无法开启新的异步线程执行任务
  21. //      信号量的空位为N,也就是说此刻可以开启N条异步线程执行任务代码
  22. //注:空位为N,表示除开当前线程之外可以另起的异步线程个数
  23. DWORD WINAPI myWorker(void * p)
  24. {
  25.     int * pInt = (int *)p;
  26.     printf("worker:%d si running! \n", *pInt);
  27.     HANDLE mySema = OpenSemaphore(SEMAPHORE_ALL_ACCESS, FALSE, id);//指定范围检索指定名称的信号量
  28.     if (mySema)//判断信号量是否存在
  29.     {
  30.         printf("worker:%d is waiting! \n", *pInt);//表示当前线程处于判定信号量状态
  31.         Sleep(1000);
  32.         if (WaitForSingleObject(mySema, INFINITE) == WAIT_OBJECT_0)//等待空位为0
  33.         {//如果信号空位为0,也就是无法开启异步线程的情况
  34.             printf("worker:%d is getting! \n", *pInt);//此时只有当前线程获得CPU执行权,其它线程无法获取CPU可执行权
  35.             Sleep(3000);
  36.             printf("worker:%d is leaving! \n", *pInt);
  37.             ReleaseSemaphore(mySema, 1, NULL);//释放信号:只是打开一个空位,也就是可以开启另外一条异步线程进行执行了
  38.             CloseHandle(mySema);//释放资源信号量资源
  39.         }
  40.     }
  41.     return 1;
  42. }
  44. //03.创建信号量:
  45. //  1.特点:初始化信号量对象
  46. //  2.格式:HANDLE mySema = CreateSemaphore(arg1, arg2, arg3, arg4);
  47. //      arg1:安全属性集
  48. //      arg2:初始空位数
  49. //      arg3:最大空位数
  50. //      arg4:信号量名称
  51. int main01(void)
  52. {
  53.     HANDLE mySema = CreateSemaphore(NULL, 0, MAX, id);
  54.     HANDLE threadArr[10] = { 0 };
  55.     for (int i = 0; i < 10; ++i)
  56.     {//由于当前信号量为0,因此多条执行同一段儿代码的时候,需要判定能否通过
  57.         threadArr[i] = CreateThread(NULL, 0, myWorker, threadArr + i, 0, NULL);
  58.     }
  59.     Sleep(5000);
  60.     printf("激活状态! \n");
  61.     ReleaseSemaphore(mySema, MAX, NULL);//释放信号量
  62.     WaitForMultipleObjects(10, threadArr, TRUE, INFINITE);
  63.     CloseHandle(mySema);
  65.     system("pause");
  66. }
  68. //01.信号量:Semaphore
  69. //  1.量值:0-1-2-3
  70. //  2.使用一次进行一次减数,到了一定的数据之后,做一些指定操作
  71. //      当数据减到至0的时候,信号为0,在使用信号量的地方,处于停滞状态
  72. //  3.信号量还可以做一些其他的限定操作
  73. //  4.线程通信:用途
  74. //  5.具备等待机制
  75. //02.信号计数原理:
  76. //  1.两个按键入口,多个行李
  77. //  2.信号衰减原理:空位原理
  78. //      信号为0的时候,没有空位为0,通过判断信号的空位情况,决定是否让线程干活儿
  79. //      等待唤醒机制0与非0的区别(非0,线程可执行,0线程不可执行)
  80. //03.关卡原理:
  81. //  1.同时最多支持10000个人购票
  82. //  2.如果超过10000个人,就需要排队
  83. //  3.当10000个人购票完毕的时候,重新开启线程执行任务
  84. //04.原理:if 0 等下去
  85. //  1.同一个信号量
  86. //  2.10个线程
  87. //  3.状态判定:
  88. //      0-->10个等待
  89. //      5-->5个等待,5个执行
  90. //          执行一次,减去一次-->信号量衰减
  91. //  4.所有的线程都能够读取到该信号量
  92. //      多个线程占用资源:等待执行状态
  93. //      用完与没有用完(线程不可执行状态与线程可执行状态)
  94. //05.信号量完全解析:
  95. //  步骤一:
  96. //      HANDLE hSEM=CreateSemaphore(NULL,0,MAX,id);
  97. //      创建一个信号量,信号量的最大值为MAX,如果等于0的情况之下,它就在这儿死等下去
  98. //  步骤二:
  99. //      ReleaseSemaphore(mySema,MAX,NULL);//释放信号量,补充空位数量
  100. //      一旦将信号量设定为5就会开始进行执行
  101. //06.什么样儿的情况之下我们使用信号量?
  102. //      实现两个线程的死锁状态,设定为1这个信号量,进或者不进
  1. ///02.SemaphoreNew.c
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <Windows.h>
  6. int num = 0;
  8. //01.信号量的应用:
  9. //  1.排队执行机制
  10. //      让多个线程处于执行状态,让多个线程处于休眠状态
  11. //  2.实现线程互斥
  12. //      让一个线程处于执行状态,让其它所有线程处于等待状态
  13. DWORD WINAPI add(void * p)
  14. {
  15.     HANDLE mySema = OpenSemaphore(SEMAPHORE_ALL_ACCESS, FALSE, L"xiaobin");//打开信号量:
  16.     if (mySema)
  17.     {
  18.         if (WAIT_OBJECT_0 == WaitForSingleObject(mySema, INFINITE))
  19.         {//判断信号强弱(判断信号量的数目,也就是判断空位数目)
  20.             for (int i = 0; i < 10000; ++i)
  21.             {
  22.                 ++num;
  23.             }
  24.             ReleaseSemaphore(mySema, 1, NULL);
  25.             CloseHandle(mySema);
  26.         }
  27.     }
  28.     else
  29.     {
  30.         printf("打开信号量失败! \n");
  31.     }
  32. }
  34. int main02(void)
  35. {
  36.     //01.实现线程互斥的关键代码:
  37.     //  最多只能有一个空位(最多只能同时有一条线程处于执行状态)
  38.     HANDLE mySema = CreateSemaphore(NULL, 0, 1, L"xiaobin");
  39.     HANDLE threadArr[64] = { 0 };
  40.     for (int i = 0; i < 64; ++i)
  41.     {
  42.         threadArr[i] = CreateThread(NULL, 0, add, NULL, 0, NULL);
  43.     }
  44.     printf("激活线程");
  45.     ReleaseSemaphore(mySema, 1, NULL);
  46.     WaitForMultipleObjects(64, threadArr, TRUE, INFINITE);
  47.     printf("num = %d \n", num);
  48.     CloseHandle(mySema);
  50.     system("pause");
  51. }
  53. //01.信号量可以实现多个线程的卡顿现象
  54. //02.信号量的空位原理-->0和1的原理:互斥特点
  55. //  入职与离职原理的特点-->空位原理
  56. //03.如何使用信号量实现一个全局变量的自增?
  57. //  互斥类型的方式实现-->使用信号量实现线程之间的互斥现象
  58. //04.随机数的求取方法:
  59. //  1.原始函数
  60. //  2.多线程的数据丢失
  61. //05.多线程处理状态下的CPU是不会稳定的情况
  62. //06.信号量:0代表没有空位-->线程等待状况
  63. //  控制访问次数
  64. //07.互斥量与信号量的区别:
  65. //  互斥量:只能让一个线程处于运行状态
  66. //  信号量:可以让多个线程处于运行状态,其他线程休眠
  67. //  临界区:只能让一个线程处于运行状态
  68. //  时间同步:
  69. //  事件:也可以实现让多个线程处于运行状态,其他线程休眠状态
  70. //  原子操作:操作速度最快,因为它不需要等待操作线程,几乎直接运行状态
  71. //注:原子量的速度快在于无需让多条线程处于等待执行状态,其他线程互斥的方式
  72. //      存在着线程等待执行的状态

程序片段(03):01.互斥.c+02.互斥读写.c

内容概要:互斥锁

  1. ///01.互斥.c
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <Windows.h>
  6. int static num = 6400000;
  8. //01.全局写入锁
  9. //  当一个线程在进行指定变量的写入操作的时候;
  10. //  其它线程若是需要写入这个指定变量数据,那么
  11. //  其他线程只能处于等待执行写入数据的状态
  12. SRWLOCK gw_lock = { 0 };
  14. static DWORD WINAPI write(void * p)
  15. {//多线程写入状态下,同一时刻只能由一条线程执行写入状态!
  16.     AcquireSRWLockExclusive(&gw_lock);//获得独立写入锁(进入锁定状态)
  17.     for (int i = 0; i < 100000; ++i)
  18.     {
  19.         --num;
  20.     }
  21.     ReleaseSRWLockExclusive(&gw_lock);//释放独立写入锁(释放锁定状态)
  22.     return 0;
  23. }
  25. int main01(void)
  26. {
  27.     InitializeSRWLock(&gw_lock);
  28.     HANDLE threadArr[64];
  29.     for (int i = 0; i < 64; ++i)
  30.     {
  31.         threadArr[i] = CreateThread(NULL, 0, write, NULL, 0, NULL);
  32.     }
  33.     //num += 10000;//没有生效,说明互斥锁的原则是全局生效,是对所有线程生效!
  34.     WaitForMultipleObjects(64, threadArr, TRUE, INFINITE);
  35.     printf("num = %d \n", num);
  37.     system("pause");
  38. }
  40. //01.互斥锁的概念:互斥
  41. //  如同交往一个女友之后就被锁定了
  42. //02.互斥锁问题:
  43. //  线程互斥:同一时刻,只能由同一个线程执行数据操作
  44. //03.线程的互斥实现方式:
  45. //  临界区-->互斥量-->原子操作-->事件-->信号量-->互斥锁
  46. //04.互斥锁的创建流程:
  47. //  全局变量:定义互斥量
  48. //      SRWLOCK g_lock;
  49. //  Main函数:初始化互斥量
  50. //      InitializeSRWLock(&g_lock);
  51. //  数据锁定:写入和读取的锁定
  52. //  线程函数:
  53. //      AcquireSRWLockExclusive(&g_lock);//锁定写入
  54. //      ReleaseSRWLockExclusive(&g_lock);//锁定释放
  55. //05.互斥锁的使用场景:
  56. //  1.改变一个变量的时候需要锁定(防止同时读取,同时写入)
  57. //  2.读取一个变量的时候也需要锁定(防止同时写入,同时读取)
  1. ///02.互斥读写.c
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <Windows.h>
  6. int num = 6400000;//待读写的数据
  8. SRWLOCK g_lock = { 0 };//写入锁
  10. DWORD WINAPI write(void * p)
  11. {
  12.     printf("开始写入! \n");
  13.     AcquireSRWLockExclusive(&g_lock);
  14.     for (int i = 0; i < 100000; ++i)
  15.     {
  16.         --num;
  17.         //Sleep(10);
  18.     }
  19.     ReleaseSRWLockExclusive(&g_lock);
  20.     printf("结束写入! \n");
  21.     return 0;
  22. }
  24. DWORD WINAPI read(void * p)
  25. {
  26.     printf("读取状态! \n");
  27.     AcquireSRWLockShared(&g_lock);
  28.     int i = 0;
  29.     while (1)
  30.     {
  31.         ++i;
  32.         Sleep(1000);
  33.         printf("第%d秒, num = %d \n", i, num);//由于写入状态锁定了,因此这里的读取状态,无法读取到数据
  34.         if (20 == i)
  35.             break;
  36.     }
  37.     ReleaseSRWLockShared(&g_lock);
  38.     printf("读取结束! \n");
  39.     return 0;
  40. }
  42. int main02(void)
  43. {
  44.     InitializeSRWLock(&g_lock);
  45.     CreateThread(NULL, 0, read, NULL, 0, NULL);
  46.     HANDLE threadArr[64] = { 0 };
  47.     for (int i = 0; i < 64; ++i)
  48.     {
  49.         threadArr[i] = CreateThread(NULL, 0, write, NULL, 0, NULL);
  50.     }
  51.     WaitForMultipleObjects(64, threadArr, TRUE, INFINITE);
  52.     printf("num = %d \n", num);
  54.     system("pause");
  55. }
  57. //01.互斥锁的读写状态控制
  58. //  写入的状态下不可读取,读取的状态下不可写入
  59. //02.锁定状态,读取完成之后才进行锁定
  60. //03.一个资源只能锁定一次,不能锁定多次
  61. //04.锁定-->防止冲突问题-->读取和写入的状态
  62. //  防止同时写入和读取数据

程序片段(04):Mutex.c

内容概要:01.跨进程Mutex(发互斥)

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <Windows.h>
  5. char name[100] = "haihualovefang";
  7. int main(void)
  8. {
  9.     //01.创建互斥量"Mutex":
  10.     //  位于内核层|Ring0层
  11.     HANDLE myMutex = CreateMutexA(NULL, TRUE, name);
  12.     printf("在内核层|Ring0层创建互斥量(Mutex)成功! \n");
  13.     char chr = getch();//实时获取单个字符
  14.     //02.释放互斥量:
  15.     //  相当于发出通知
  16.     ReleaseMutex(myMutex);
  17.     //03.关闭互斥量:
  18.     CloseHandle(myMutex);
  19.     system("pause");
  20. }
  22. //01.关于跨进程的驱动访问:内核对象
  23. //  无论是Windows还是Linux都是存在互斥量说法
  24. //02.如果是跨进程的话:
  25. //  创建跨进程的Mutext需要有名称(便于全局访问)
  26. //03.编写网络程序的时候:
  27. //  既需要编写客户端也需要编写网络端
  28. //  -->编写两个程序的时代
  29. //04.演示的时候需要:
  30. //  进行编译好的程序之间的演示
  31. //05.跨进程通信:
  32. //  1.Event&Mutex&semaphore都可以实现跨进程的线程通信
  33. //  2.Mutex是最安全的跨进程线程访问(因为能够处理发送通知方的断开情况)
  34. //      发出通信信息的进程退出情况能够处理!

程序片段(05):Mutex.c

内容概要:02.跨进程Mutex(收互斥)

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <Windows.h>
  5. char name[100] = "haihualovefang";
  7. int main(void)
  8. {
  9.     //01.打开互斥量:
  10.     //  作用:获取互斥量
  11.     //  格式:HANDLE mutex = OpenMutexA(arg1, arg2, arg3);
  12.     //      mutex:互斥量+arg1:检索范围+arg2:继承句柄+互斥量名称
  13.     HANDLE myMutex = OpenMutexA(MUTEX_ALL_ACCESS, TRUE, name);//获取互斥量
  14.     //if (NULL == myMutex)//判定互斥量
  15.     //{
  16.     //  printf("获取互斥量失败! \n");
  17.     //  system("pause");
  18.     //  return;
  19.     //}
  20.     printf("等待状态! \n");
  21.     //02.控制互斥量的等待时间:
  22.     //  先获得互斥量-->设定等待状态时间(等待指定的时间范围!)
  23.     DWORD res = WaitForSingleObject(myMutex, 10000);//设置等待状态
  24.     switch (res)
  25.     {
  26.     case WAIT_OBJECT_0:
  27.         printf("收到跨进程信号! \n");
  28.         break;
  29.     case WAIT_TIMEOUT:
  30.         printf("等待跨进程信号超时! \n");
  31.         break;
  32.     case WAIT_ABANDONED:
  33.         printf("另外一个进程发生终止!结束跨进程信号等待状态! \n");
  34.         break;
  35.     default:
  36.         break;
  37.     }
  39.     CloseHandle(myMutex);
  40.     system("pause");
  41. }
  43. //01.刚才的程序特点:
  44. //  都是出于同一个进程内的线程操作(同一进程)
  45. //02.C++关于"事件"和"信号量"的封装:
  46. //  封装通用的一个机制,Cocos2dx的时候都是一样的情况
  47. //  包含OC也一样,只不过它们将接口内容进行了简化
  48. //03.多线程的强化:
  49. //  1.event&mutex&semaphore:(驱动层|Ring0层)
  50. //      本质:是处于驱动里面的一个综合信号量
  51. //  2.操作系统起到什么作用?
  52. //      (1).操作系统类似于一个巨大的进程,里面运行的每个程序类似于线程
  53. //          (类比:大进程&进程)<--->(进程&线程)
  54. //      (2).电脑重启,打开多个.exe都需要重启
  55. //      (3).操作系统和应用程序之间的关系就如同进程和线程之间的关系
  56. //      (4).高级机制:内核对象(Ring0层对象)
  57. //04.操作系统的高级机制:内核对象-->项目使用-->跨进程使用
  58. //  1.操作系统的分层机制:
  59. //      (1).ring0:就是最底层,这里可以用于编写驱动(出错:蓝屏)
  60. //      (2).ring3:就是应用层,(出错:进程出错)
  61. //  2.线程互斥区分机制:
  62. //      (1).event&mutex:
  63. //          这里创建的指针处于应用层,但是指针所指向的内存处于ring0层
  64. //              ring0层当中的对象可以看到所有进程的内存(最高访问权限)
  65. //      (2).进程之间不可以进行相互读写,必须通过注射方式
  66. //      (3).event&mutex都是出于ring0层的内核对象
  67. //          本质:对象的底层特点
  68. //          所以:它们不仅可以用于一个进程内的线程互斥,还可以用于多个进程之间的线程互斥
  69. //05.mutex的互斥问题解析:
  70. //  1.跨进程的mutex互斥问题
  71. //  2.C++的线程库都是对C语言多线程的封装
  72. //          大概原理-->C++的类使用
  73. //06.关于跨进程通信的问题:
  74. //  最好使用互斥量(mutex)实现跨进程通信
  75. //  原因:其他方式(event&semaphore)不能处理进程断开的情况!

程序片段(06):发事件.c

内容概要:01.跨进程Event(发事件)

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <Windows.h>
  5. char name[100] = "haihualovefang";
  7. //01.Event实现跨进程通信:
  8. //  1.这儿的Event不是线程级别的含义,而是进程级别的含义:
  9. //      该Event实质上是位于(内核|Ring0层),因此可以实现跨进程通信
  10. //  2.参数说明:第二个参数表示是否重置手动重置事件状态
  11. //      TRUE:手动重置+FALSE:自动重置
  12. int main(void)
  13. {
  14.     HANDLE myEvent = CreateEventA(NULL, FALSE, FALSE, name);//创建事件
  15.     printf("跨进程Event创建成功! \n");
  16.     char chr = getch();
  17.     SetEvent(myEvent);//设置事件
  18.     printf("发送跨进程Event事件! \n");
  20.     CloseHandle(myEvent);
  21.     system("pause");
  22. }
  24. //01.严格区分跨线程和跨进程
  25. //02.使用Event实现跨进程线程访问
  26. //03.Event和Mutex有一定的区别:
  27. //  Event跨进程不能使用匿名的,否则的话找不到
  28. //注:跨进程一定要采用唯一名称标识信号
  29. //04.TCP/UDP的时候就是如此复杂的情况
  30. //05.一般进程与进程之间都需要设定一个超时等待时间
  31. //06.Event天生的缺陷:
  32. //  只有Mutex可以感知到另外一个进程的丢失
  33. //  Event不具备感知进程丢失的功能
  34. //注:进程通信情况之下的进程丢失情况分析!

程序片段(07):收事件.c

内容概要:02.跨进程Event(收事件)

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <Windows.h>
  5. char name[100] = "haihualovefang";
  7. int main(void)
  8. {
  9.     //01.打开事件:
  10.     //  获取跨进程所创建的事件
  11.     HANDLE myEvent = OpenEventA(EVENT_ALL_ACCESS, TRUE, name);//获取事件
  12.     if (NULL == myEvent)
  13.     {
  14.         printf("跨进程Event获取失败! \n");
  15.         system("pause");
  16.         return;
  17.     }
  18.     printf("跨进程Event等待状态! \n");
  19.     DWORD res = WaitForSingleObject(myEvent, 10000);
  20.     switch (res)
  21.     {
  22.     case WAIT_OBJECT_0:
  23.         printf("跨进程Event收到状态! \n");
  24.         break;
  25.     case WAIT_TIMEOUT:
  26.         printf("跨进程Event超时状态! \n");
  27.         break;
  28.     case WAIT_ABANDONED:
  29.         printf("另外一个进程已经中止! \n");
  30.         break;
  31.     default:
  32.         break;
  33.     }
  35.     CloseHandle(myEvent);
  36.     system("pause");
  37. }

程序片段(08):发信号.c

内容概要:01.跨进程Semaphore(发信号)

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <Windows.h>
  5. char name[100] = "haihualovefang";
  7. int main(void)
  8. {
  9.     HANDLE mySema = CreateSemaphoreA(NULL, 0, 1, name);
  10.     printf("跨进程Semaphore信号量创建成功! \n");
  11.     char chr = getch();
  12.     ReleaseSemaphore(mySema, 1, NULL);
  13.     printf("跨进程Semaphore发出信号! \n");
  15.     CloseHandle(mySema);
  16.     system("pause");
  17. }
  19. //01.当一条线程做完一件事情之后,需要通知其他线程的时候:
  20. //  这个时候就需要进行线程之间的通信
  21. //注:区分线程通信与进程通信
  22. //02.大数据你就得将图论和树结构玩儿的相当好才行
  23. //  图和树就是用于管理这么多的线程的
  24. //03.线程与线程之间的关系是很复杂的:
  25. //  需要掌握逻辑&排序&容错&模糊
  26. //04.跨进程的线程通信:
  27. //  Event&Mutex&Semaphore
  28. //05.使用跨进程通信的时候:
  29. //  1.最佳解决方案就是Mutex
  30. //  2.缺点比较:
  31. //      Event&Semaphore:发信信号的进程关闭之后无法感知到!
  32. //      Mutex:发送信号的进程关闭之后能够被感知到!

程序片段(09):收信号.c

内容概要:02.跨进程Semaphore(收信号)

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <Windows.h>
  5. char name[100] = "haihualovefang";
  7. int main(void)
  8. {
  9.     HANDLE mySema = OpenSemaphoreA(SEMAPHORE_ALL_ACCESS, TRUE, name);
  10.     if (NULL == mySema)
  11.     {
  12.         printf("跨进程Semaphore创建失败! \n");
  13.         system("pause");
  14.         return;
  15.     }
  16.     printf("跨进程Semaphore等待状态! \n");
  17.     DWORD res = WaitForSingleObject(mySema, 10000);
  18.     switch (res)
  19.     {
  20.     case WAIT_OBJECT_0:
  21.         printf("跨进程Semaphore通信收到! \n");
  22.         break;
  23.     case WAIT_TIMEOUT:
  24.         printf("跨进程Semaphore通信超时! \n");
  25.         break;
  26.     case WAIT_ABANDONED:
  27.         printf("另外一个进程已经中止! \n");
  28.         break;
  29.     default:
  30.         break;
  31.     }
  33.     CloseHandle(mySema);
  34.     system("pause");
  35. }

程序片段(10):TimePrc.c

内容概要:时间同步

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <Windows.h>
  5. //01.时间同步:标准回调函数格式
  6. //  1.小写"void"和大写"VOID"实质一样-->在这儿只是回调函数的规范
  7. //  2.参数:普通指针+时间1[低点]+时间2[高点]-->相当于时差
  8. //  3.创建一个回调函数格式的函数指针常量
  9. //  4.回调函数:CALLBACK的标识定义(标准定义)
  10. VOID CALLBACK timeRun(void * pArg, DWORD timeLow, DWORD timeHigh)
  11. {
  12.     DWORD dwindex = *(DWORD *)pArg;
  13.     printf("第%d次! \n", dwindex);
  14.     MessageBoxA(0, "1", "2", 0);
  15. }
  17. //02.Win操作系统之下使用系统自带的定时器资源:
  18. //  1.创建定时器:有几个函数-->起到等待作用的定时器
  19. //  2.参数:arg1,arg2,arg3-->arg3是定时器的名称
  20. //  3.匿名定时器只能有一个,携带名称的定时器可以有多个!
  21. int main(void)
  22. {
  23.     HANDLE time1 = CreateWaitableTimerA(NULL, TRUE, "haihua");
  24.     if (NULL == time1)
  25.     {
  26.         printf("定时器创建失败! \n");
  27.     }
  28.     //设置定时器特点
  29.     LARGE_INTEGER myTime;
  30.     myTime.QuadPart = -50000000;//单位:0.1微妙--万分之一毫秒
  31.     //SetWaitTimer:定义解释
  32.     //  _In_ HANDLE hTimer;定时器
  33.     //  _In_ const LARGE_INTEGER * 1pDueTime;//时间
  34.     //  _In_ LONG 1Period;//循环次数
  35.     //  _In_opt_ PTIMERAPCROUTINE pfnCompletionRoutine;//函数指针
  36.     //  _In_opt_ LPVOID 1pArgToCompletionRoutline;//参数
  37.     //  _In_ BOOL fResume;//始终恢复状态
  38.     //设置等待的定时器(等待定时器)
  39.     DWORD dwparam = 1;
  40.     //1000说明1000毫秒-->1分钟干一次,回调间隔
  41.     if (SetWaitableTimer(time1, &myTime, 1000, timeRun, &dwparam, FALSE))
  42.     {//五秒钟之后触发该事件:1|0
  43.         printf("等待5秒之后开始干活儿! \n");
  44.         for (int i = 0; i < 15; ++i, ++dwparam)
  45.         {//执行次数-->循环多少次,就回调多少次
  46.             SleepEx(INFINITE, TRUE);
  47.         }
  48.     }
  49.     //循环完毕之后所需执行的操作:
  50.     //  取消定时器和关闭句柄资源
  51.     CancelWaitableTimer(time1);
  52.     CloseHandle(time1);
  54.     if (WAIT_OBJECT_0 == WaitForSingleObject(time1, INFINITE))
  55.     {//等待消息成功
  56.         printf("wait ok! \n");
  57.     }
  58.     else
  59.     {
  60.         printf("wait no! \n");
  61.     }
  63.     system("pause");
  64. }
  66. //01.多线程与队列:
  67. //  实现文件加密
  68. //02.关于"时间定时器"的一些操作:
  69. //  简单定时器-->允许回调函数
  70. //03.时间同步问题:
  71. //  1.主要用于解决多个线程的时间问题[多线程]
  72. //  2.围绕时间定时器,每隔一段事件干一定的活儿
  73. //  3.满足一定的时间条件,然后解决一定的问题
  74. //04.回调函数与时间的概念:
  75. //  1.触发函数的动作-->回调动作
  76. //  2.执行完一段代码之后,执行某一个函数
  77. //05.回调函数原理:
  78. //  1.数据1,2-->根据符号进行运算
  79. //  2.整体函数[参数1+参数2+函数指针]
  80. //  3.定时器触发一个函数的执行
  81. //  4.多个线程在同一时间要干某些事件
  82. //06.同一个事件通知多个事件的执行
  83. //07.回调函数:Callback
  84. //  1.函数指针,可以进行调用-->实现任何代码都可以进行自定义
  85. //  2.整合功能:自定义功能以及它定义功能
  86. //08.函数指针:新的功能-->函数指针-->功能随时更换
  87. //  1.百度搜索原理
  88. //  2.百度后台的搜索算法的改变
  89. //  3.用户调用的时候会根据函数指针的区别[付钱状态,区域]
  90. //09.创建多个定时器需要根据名称进行区分
  91. //10.定时器的使用步骤:
  92. //  1.创建定时器:
  93. //      HANDLE time1=CreateWaitableTimerA(NULL,TRUE,"haihua");
  94. //  2.五秒钟之后启动定时器:
  95. //      LARGE_INTEGER mytime;
  96. //      mytime.QuadPart=-50000000;
  97. //  3.定时器回调函数:
  98. //      if(SetWaitableTimer(time1,&mytime,3000,timerun,&dwparam,FALSE)){}
  99. //      回调周期:3000毫秒之后循环一次-->循环多少次
  100. //11.时间同步:主要用于游戏的开发
  101. //  内核对象:游戏开发-->为了时间而单独编写一条线程不划算
  102. //  CreateWaitableTimerA();-->内核对象
  103. //  SetWaitableTimer();-->内核对象
  104. //  内核对象-->多个时钟都有一个名称-->我就可以让多个线程同时读取一个时钟,进行操作,避免耗费资源

程序片段(11):volatile.c

内容概要:Volatile

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <limits.h>
  5. void main01()
  6. {
  7.     for (volatile int i = 0; i < INT_MAX; i++)
  8.     {//(1)区分Debug模式和Release[+]模式
  9.         //(2)优化:强制读取内存
  10.     }
  12.     system("pause");
  13. }
  15. void main02()
  16. {
  17.     volatile int i = 10;
  18.     int a = i;
  19.     printf("\ni=%d", a);
  21.     //{偷偷改变i的值}
  22.     _asm
  23.     {//(1)_asm是汇编语言
  24.         //(2)修改数据-->栈底的内存是ebp,这里让其-4,也就是i这个栈底数据的改变
  25.         //(3)16进制的20h=32
  26.         //(4)这里的i已经不再寄存器里面,所以volatile强制读取内存当中经过修改之后的数据
  27.         //(5)ebp-4相当于栈底的指针:直接修改数据
  28.         mov dword ptr[ebp - 4], 20h;
  29.     }
  31.     int b = i;
  32.     printf("\ni=%d", b);
  34.     getchar();
  35. }
  37. //01.Volatile强化:
  38. //  主要解决强制读取内存的动作
  39. //02.Volatile原理:寄存器-内存
  40. //  1.寄存器读取i的值,然后赋值给a,b
  41. //  2.当检测到i没有被修改的时候,读取寄存器中的i值
  42. //  3.写入到a,b当中-->于是就缺少了读取内存的一次
  43. //  4.只是读取了一次内存当中的i值
  44. //03.数据被意外改变的情况之下经常使用Volatile
  45. //  数据意外改变-->编译器优化-->不读取内存[失误]

程序片段(12):Queue.h+Queue.c+数组顺序队列.c

内容概要:01.数组顺序队列

  1. ///Queue.h
  2. #pragma once
  4. #define DT int
  5. #define EN 100
  7. typedef struct queue
  8. {
  9.     int head;
  10.     int tail;
  11.     DT arr[EN];
  12. } Queue;
  14. void initQueue(Queue * pQueue);
  16. int queueIsFull(Queue * pQueue);
  18. void enQueue(Queue * pQueue, DT data);
  20. int queueIsEmpty(Queue * pQueue);  
  22. void showQueue(Queue * pQueue);
  24. DT queuGetHead(Queue * pQueue);
  26. void deQueue(Queue * pQueue);
  1. ///Queue.c
  2. #include "Queue.h"
  3. #include <stdlib.h>
  4. #include <memory.h>
  6. void initQueue(Queue * pQueue)
  7. {
  8.     if (NULL == pQueue)
  9.         abort();
  10.     memset((*pQueue).arr, 0, EN * sizeof(DT));
  11.     (*pQueue).tail = (*pQueue).head = 0;
  12. }
  14. int queueIsFull(Queue * pQueue)
  15. {
  16.     if (NULL == pQueue)
  17.         abort();
  18.     if (EN == (*pQueue).tail)
  19.         return 1;
  20.     return 0;
  21. }
  23. void enQueue(Queue * pQueue, DT data)
  24. {
  25.     if (NULL == pQueue)
  26.         abort();
  27.     if (queueIsFull(pQueue))
  28.         return;
  29.     (*pQueue).arr[(*pQueue).tail] = data;
  30.     ++(*pQueue).tail;
  31. }
  33. int queueIsEmpty(Queue * pQueue)
  34. {
  35.     if (NULL == pQueue)
  36.         abort();
  37.     if ((*pQueue).head == (*pQueue).tail)
  38.         return 1;
  39.     return 0;
  40. }
  42. void showQueue(Queue * pQueue)
  43. {
  44.     if (NULL == pQueue)
  45.         abort();
  46.     if (queueIsEmpty(pQueue))
  47.         return;
  48.     for (int i = 0; i < (*pQueue).tail; ++i)
  49.     {
  50.         printf("%3d", (*pQueue).arr[i]);
  51.     }
  52.     printf("\n");
  53. }
  55. DT queueGetHead(Queue * pQueue)
  56. {
  57.     if (NULL == pQueue)
  58.         abort();
  59.     if (queueIsEmpty(pQueue))
  60.         return;
  61.     return (*pQueue).arr[0];
  62. }
  64. //01.几种特殊数据结构的实现方式:
  65. //  1.栈结构:
  66. //      数组栈:tail-=1(无所谓正向和反向)
  67. //      链表栈:
  68. //          正向:尾部增加,尾部减少
  69. //          反向:头部增加,头部减少
  70. //  2.队列结构:
  71. //      数组队列:正反向的效率一致
  72. //      链表队列:
  73. //          正向:尾部增加,头部减少
  74. //          反向:头部增加,尾部减少
  75. //注:数组队列,存在明显缺点,需要进行内存移动!
  76. //      队列的损耗,移动费时费力!
  77. //注:解决数组移动移动费时费力的方案:
  78. //      改造成环数组形队列+改造成链表队列
  79. void deQueue(Queue * pQueue)
  80. {
  81.     if (NULL == pQueue)
  82.         abort();
  83.     if (queueIsEmpty(pQueue))
  84.         return;
  85.     for (int i = 0; i < (*pQueue).tail - 1; ++i)
  86.     {
  87.         (*pQueue).arr[i] = (*pQueue).arr[i + 1];
  88.     }
  89.     --(*pQueue).tail;
  90. }
  1. ///数组顺序队列.c
  2. #include "Queue.h"
  3. #include <stdio.h>
  4. #include <stdlib.h>
  6. int main01(void)
  7. {
  8.     Queue queue;
  9.     initQueue(&queue);
  10.     for (int i = 0; i < 10; ++i)
  11.     {
  12.         enQueue(&queue, i);
  13.     }
  14.     showQueue(&queue);
  15.     while (!queueIsEmpty(&queue))
  16.     {
  17.         printf("出队的数据是%3d \n", queueGetHead(&queue));
  18.         deQueue(&queue);
  19.         showQueue(&queue);
  20.     }
  22.     system("pause");
  23. }
  25. //01.顺序队列:逻辑编程
  26. //  工厂模式+(生产者-消费者)模式+请求响应模式
  27. //02.生产者与消费者:
  28. //  1.生产线程(生产者)
  29. //  2.消费线程(消费者)
  30. //  3.库存情况:库存越少越好,但是不能断掉供应链
  31. //      队列关系:生产者生产,消费者消费
  32. //      顺序关系:先进先出特点(存在顺序)
  33. //      原理:队列&多线程--请求|响应模式
  34. //03.三种队列的实现:
  35. //  1.数组顺序队列(尾部插入,头部取出)
  36. //  2.数组环形顺序队列(尾部插入,头部取出)
  37. //  2.链表反向队列(头部插入,尾部取出)
  38. //      队列实现:基础之上实现
  39. //          (生产者&消费者)模式
  40. //          (发送消息&接收消息)的模式
  41. //          (请求&响应)模式
  42. //04.数组顺序队列-->数组环形顺序队列
  43. //  单链表-->双链表:单独的结构-->追求快一点儿,从简
  44. //05.环形队列原理:
  45. //  1.吃东西-->拉东西
  46. //  2.吃:前面+,拉:往前走
  47. //  3.吃的太多,重合情况(特殊情况)
  48. //06.环形队列解释:
  49. //  1.头尾重合,没有数据,添加一个数据之后,头不变,尾向后移一个结构体单位
  50. //  2.顺序队列的缺点:删除的时候移动很累(数组环形队列可以解决这个问题)
  51. //07.顺序队列解释:
  52. //  1.头部必须固定
  53. //  2.移动费时费力
  54. //08.队列移动问题的改造:
  55. //  1.链表结构
  56. //  2.环形队列

程序片段(13):CircleQueue.h+CircleQueue.c+数组正向环形队列.c

内容概要:02.数组环形顺序队列

  1. ///CircleQueue.h
  2. #pragma once
  4. #define DT int
  5. #define EN 0
  7. typedef struct circleQueue
  8. {
  9.     int head;
  10.     int tail;
  11.     DT arr[EN];
  12. } CircleQueue;
  14. void initCircleQueue(CircleQueue * pCircleQueue);
  16. int circleQueueIsFull(CircleQueue * pCircleQueue);
  18. void enCircleQueue(CircleQueue * pCircleQueue, DT data);
  20. int circleQueueIsEmpty(CircleQueue * pCircleQueue);
  22. void showCircleQueue(CircleQueue * pCircleQueue);
  24. DT circleQueueGetHead(CircleQueue * pCircleQueue);
  26. void deCircleQueue(CircleQueue * pCircleQueue);
  1. ///CircleQueue.c
  2. #include "CircleQueue.h"
  3. #include <stdlib.h>
  4. #include <memory.h>
  6. void initCircleQueue(CircleQueue * pCircleQueue)
  7. {
  8.     if (NULL == pCircleQueue)
  9.         abort();
  10.     memset((*pCircleQueue).arr, 0, EN * sizeof(DT));
  11.     (*pCircleQueue).tail = (*pCircleQueue).head = 0;
  12. }
  14. //01.如何判断环形队列是否装满元素?
  15. //  1.这儿有三种特殊情况需要考虑:
  16. //      头部+中部+尾部
  17. //  2.最终可归结为两种环形队列满元素的情况:
  18. //      头部+中部(尾部和头部合并)
  19. //  3.归纳总结:
  20. //      头尾+循环情况
  21. int circleQueueIsFull(CircleQueue * pCircleQueue)
  22. {
  23.     if (NULL == pCircleQueue)
  24.         abort();
  25.     if ((*pCircleQueue).head == ((*pCircleQueue).tail + 1) % EN)
  26.     {
  27.         return 1;
  28.     }
  29.     return 0;
  30. }
  32. void enCircleQueue(CircleQueue * pCircleQueue, DT data)
  33. {
  34.     if (NULL == pCircleQueue)
  35.         abort();
  36.     if (circleQueueIsFull(pCircleQueue))
  37.         return;
  38.     (*pCircleQueue).arr[(*pCircleQueue).tail] = data;
  39.     (*pCircleQueue).tail = ((*pCircleQueue).tail + 1) % EN;
  40. }
  42. int circleQueueIsEmpty(CircleQueue * pCircleQueue)
  43. {
  44.     if (NULL == pCircleQueue)
  45.         abort();
  46.     if ((*pCircleQueue).head == (*pCircleQueue).tail)
  47.         return 1;
  48.     return 0;
  49. }
  1. ///数组正向环形队列.c
  2. //01.数组顺序环形队列的思想:
  3. //  1.就是把数组当成闭合顺序环形队列(数组-->抽象-->环形队列)
  4. //  2.思想演示:
  5. //      (1).原型:1         2       3       4       5       6       7       8       9       10
  6. //                         rear                                        front
  7. //      (2).抽离:8         9       10  1       2
  8. //          原理:普通数组抽象为顺序环形队列
  9. //              1).front-->rear:两个指针轮询移动
  10. //              2).防止front和rear:都走到头的情况
  11. //              3).节约移动情况(环形队列的优点)
  12. //02.环形队列实现:
  13. //  数组法+链表法
  14. //  顺序法+逆序法
  15. //03.环形队列的应用场景:
  16. //  操作系统对线程的管理这块儿
  17. //04.环形队列的两种情况:
  18. //  头尾情况+中部情况
  19. //05.环形队列:情况分析
  20. //  头尾+中部最终利用一个表达式进行表示
  21. //06.环形链表:
  22. //  1.rear说明了元素的个数
  23. //      front=0&rear=5的情况
  24. //  2.rear重合情况二
  25. //  3.一般情况之下,要是想实现环形队列,数组或者链表都
  26. //      需要空出一个位置,防止front&rear重合
  27. //07.环形链表规则指定:
  28. //  1.为空:避免重合和满了的情况一致
  29. //  2.rear+1%5的特点-->代表存储继续前进
  30. //  3.满的情况综合:
  31. //      (rear+1)%5==front说明重合装满

程序片段(15):CircleQueue.h+CircleQueue.h+数组正向环形队列.c

内容概要:01.数组正向环形队列

  1. ///CircleQueue.h
  2. #pragma once 
  4. #define DT int
  5. #define EN 10
  7. //01.数组正向环形队列:
  8. //  优点:出队一个元素,无需进行队列数组元素的整体移动
  9. //  特点:如果模拟数组的长度为N
  10. //      普通队列:需要使用到N个元素
  11. //      环形队列:需要使用到N-1个元素
  12. //注:留出一个空位是为了区分队列重合情况和队列满载情况
  13. //  普通重合情况:就是空队列
  14. //  特殊重合情况:就是满队列
  15. typedef struct circleQueue
  16. {
  17.     DT arr[EN];
  18.     int head;
  19.     int tail;
  20. }CircleQueue;
  22. void initCircleQueue(CircleQueue * pCircleQueue);
  24. int circleQueueIsFull(CircleQueue * pCircleQueue);
  26. void enCircleQueue(CircleQueue * pCircleQueue, DT data);
  28. int circleQueueIsEmpty(CircleQueue * pCircleQueue);
  30. void showCircleQueue(CircleQueue * pCircleQueue);
  32. DT circleQueueGetHead(CircleQueue * pCircleQueue);
  34. void deCircleQueue(CircleQueue * pCircleQueue);
  1. ///CircleQueue.c
  2. #include "CircleQueue.h"
  3. #include <stdlib.h>
  4. #include <memory.h>
  5. #include <stdio.h>
  7. void initCircleQueue(CircleQueue * pCircleQueue)
  8. {
  9.     if (NULL == pCircleQueue)
  10.         abort();
  11.     memset((*pCircleQueue).arr, 0, EN * sizeof(DT));
  12.     (*pCircleQueue).tail = (*pCircleQueue).head = 0;
  13. }
  15. int circleQueueIsFull(CircleQueue * pCircleQueue)
  16. {
  17.     if (NULL == pCircleQueue)
  18.         abort();
  19.     if ((*pCircleQueue).head == ((*pCircleQueue).tail + 1) % EN)
  20.         return 1;
  21.     return 0;
  22. }
  24. //01.空位主要的作用:
  25. //  1.为了缓冲末尾位置可以进行循环填充数据!
  26. //  2.为了可以准确区分环形队列的两种情况:
  27. //      空队列+满队列
  28. //注:还可以确定最后一个入队的元素到底应当放置于何处!
  29. void enCircleQueue(CircleQueue * pCircleQueue, DT data)
  30. {
  31.     if (NULL == pCircleQueue)
  32.         abort();
  33.     if (circleQueueIsFull(pCircleQueue))
  34.         return;
  35.     (*pCircleQueue).arr[(*pCircleQueue).tail] = data;
  36.     (*pCircleQueue).tail = ((*pCircleQueue).tail + 1) % EN;
  37. }
  39. int circleQueueIsEmpty(CircleQueue * pCircleQueue)
  40. {
  41.     if (NULL == pCircleQueue)
  42.         abort();
  43.     if ((*pCircleQueue).head == (*pCircleQueue).tail)
  44.         return 1;
  45.     return 0;
  46. }
  48. void showCircleQueue(CircleQueue * pCircleQueue)
  49. {
  50.     if (NULL == pCircleQueue)
  51.         abort();
  52.     if (circleQueueIsEmpty(pCircleQueue))
  53.         return;
  54.     //环形队列:元素不确定+起点不确定(无法确定循环次数)
  55.     int i = (*pCircleQueue).head;
  56.     int count = 0;
  57.     do
  58.     {
  59.         printf("%3d", (*pCircleQueue).arr[(i++) % EN]);
  60.         if (9 == ++count)
  61.             break;
  62.     } while ((((*pCircleQueue).tail + 1) % EN != i % EN) && (i %EN < (*pCircleQueue).tail));
  63.     printf("\n");
  64. }
  66. DT circleQueueGetHead(CircleQueue * pCircleQueue)
  67. {
  68.     if (NULL == pCircleQueue)
  69.         abort();
  70.     if (circleQueueIsEmpty(pCircleQueue))
  71.         return -1;
  72.     return (*pCircleQueue).arr[(*pCircleQueue).head];
  73. }
  75. void deCircleQueue(CircleQueue * pCircleQueue)
  76. {
  77.     if (NULL == pCircleQueue)
  78.         abort();
  79.     if (circleQueueIsEmpty(pCircleQueue))
  80.         return;
  81.     (*pCircleQueue).head = ((*pCircleQueue).head + 1) % EN;
  82. }
  1. ///数组正向环形队列.c
  2. #include "CircleQueue.h"
  3. #include <stdio.h>
  4. #include <stdlib.h>
  6. int main01(void)
  7. {
  8.     CircleQueue circleQueue;
  9.     initCircleQueue(&circleQueue);
  10.     for (int i = 0; i < 9; ++i)
  11.     {
  12.         enCircleQueue(&circleQueue, i + 1);
  13.         showCircleQueue(&circleQueue);
  14.     }
  15.     while (!circleQueueIsEmpty(&circleQueue))
  16.     {
  17.         printf("数组正向环形队列出队:%3d \n", circleQueueGetHead(&circleQueue));
  18.         deCircleQueue(&circleQueue);
  19.         showCircleQueue(&circleQueue);
  20.     }
  22.     system("pause");
  23. }

程序片段(16):Queue.h+Queue.c+数组正向环形队列.c

内容概要:02.数组正向环形队列(标准版)

  1. ///Queue.h
  2. #pragma once
  4. #define DT int
  5. #define EN 10
  7. //01.采用数组模拟队列的两种特点:
  8. //  1.假设待用于模拟的数组共有N个元素
  9. //  2.两种目标队列模型:
  10. //      普通队列:数组正向队列,使用N个元素
  11. //      环形队列:数组正向环形队列,使用N-1个元素
  12. //注:环形队列,删除一个元素便无需移动
  13. typedef struct queue
  14. {
  15.     DT arr[EN];
  16.     int head;
  17.     int tail;
  18. }Queue;
  20. void initQueue(Queue * pQueue);
  22. int queueIsFull(Queue * pQueue);
  24. void enQueue(Queue * pQueue, DT data);
  26. int queueIsEmpty(Queue * pQueue);
  28. void showQueue(Queue * pQueue);
  30. DT queueGetHead(Queue * pQueue);
  32. void deQueue(Queue * pQueue);
  1. ///Queue.c
  2. #include "Queue.h"
  3. #include <stdlib.h>
  4. #include <memory.h>
  5. #include <stdio.h>
  7. void initQueue(Queue * pQueue)
  8. {
  9.     if (NULL == pQueue)
  10.         abort();
  11.     memset((*pQueue).arr, 0, EN * sizeof(DT));
  12.     (*pQueue).tail = (*pQueue).head = 0;
  13. }
  15. //01.区分:数组正向环形队列的两种情况
  16. //  1.空队列:起始位置=终止位置
  17. //  2.满队列:起始位置=(终止位置+1)%EN;
  18. //注:关于环形队列的面试填空问题
  19. //  1.预留一个空数组元素用作这两种情况的区分
  20. //      空队列和满队列的准确区分
  21. //  2.使得环形队列的循环利用情况得到维持
  22. //      能够循环利用到环形队列当中的每个元素位置
  23. //  3.极端情况分析:
  24. //      (1).头尾:head<tail
  25. //      (2).中间:head>tail
  26. //      (3).相同:head=tail
  27. int queueIsFull(Queue * pQueue)
  28. {
  29.     if (NULL == pQueue)
  30.         abort();
  31.     if ((*pQueue).head == ((*pQueue).tail + 1) % EN)
  32.     {
  33.         return 1;
  34.     }
  35.     return 0;
  36. }
  38. //02.数组正向环形队列的入队比数组正向队列麻烦多了:
  39. //  1.特点就是:始终在模拟正向环形队列的数组当中空余一个元素位置
  40. //      用作区分空队列和满队列以及维持环形队列的循环状况
  41. //  2.走环形的特点!充分利用取余运算符的特点
  42. //注:取余运算符能够杜绝两种特殊情况:
  43. //      起点刚好冲数组首位置开始的情况
  44. //      起点不是位于数组首位置的情况
  45. //  特:在这两种情况之下都能够维持空余一个元素位置的特点
  46. //最后一个位置无论何种情况都不会被使用到!
  47. void enQueue(Queue * pQueue, DT data)
  48. {
  49.     if (NULL == pQueue)
  50.         abort();
  51.     if (queueIsFull(pQueue))
  52.         return;
  53.     (*pQueue).arr[(*pQueue).tail] = data;
  54.     (*pQueue).tail = ((*pQueue).tail + 1) % EN;//就是为了一定要空余最后一个位置
  55. }
  57. //03.空队列的两种情况:
  58. //  重合点为:(起点位置or终点位置)
  59. // 重合点为:模拟数组的任何位置!
  60. //注:实质上就是两点重合!
  61. int queueIsEmpty(Queue * pQueue)
  62. {
  63.     if (NULL == pQueue)
  64.         abort();
  65.     if ((*pQueue).head == (*pQueue).tail)
  66.         return 1;
  67.     return 0;
  68. }
  70. void showQueue(Queue * pQueue)
  71. {
  72.     if (NULL == pQueue)
  73.         abort();
  74.     for (int i = (*pQueue).head; i % EN < (*pQueue).tail ; ++i)
  75.     {
  76.         printf("%3d", (*pQueue).arr[i]);
  77.     }
  78.     printf("\n");
  79. }
  81. DT queueGetHead(Queue * pQueue)
  82. {
  83.     if (NULL == pQueue)
  84.         abort();
  85.     if (queueIsEmpty(pQueue))
  86.         return;
  87.     return (*pQueue).arr[(*pQueue).head];
  88. }
  90. void deQueue(Queue * pQueue)
  91. {
  92.     if (NULL == pQueue)
  93.         abort();
  94.     if (queueIsEmpty(pQueue))
  95.         return;
  96.     (*pQueue).head = ((*pQueue).head + 1) % EN;
  97. }
  1. ///数组正向环形队列.c
  2. #include "Queue.h"
  3. #include <stdio.h>
  4. #include <stdlib.h>
  6. int main02(void)
  7. {
  8.     //for (int i = 0;;++i)
  9.     //{
  10.     //  printf("%2d", i %10);
  11.     //}
  13.     Queue queue;
  14.     initQueue(&queue);
  15.     for (int i = 0; i < EN - 1; ++i)
  16.     {
  17.         enQueue(&queue, i + 1);
  18.         showQueue(&queue);
  19.     }
  20.     while (!queueIsEmpty(&queue))
  21.     {
  22.         printf("%3d", queueGetHead(&queue));
  23.         deQueue(&queue);
  24.     }
  26.     system("pause");
  27. }
  29. //01.环形队列:
  30. //  1.最后一个坑用于表示模拟结束:标识结束
  31. //      标识结束+区分空队列和满队列+可循环利用
  32. //  2.环形队列原理深究:
  33. //      环形队列的优先级问题-->顺序队列同样有
  34. //注:优先队列
  35. //02.环形队列的应用:
  36. //  1.高效应用
  37. //  2.操作系统在一段时间之内只能运行一个线程
  38. //03.操作系统的特点:
  39. //  1.我一段时间限定内只能运行一段儿程序,所以操作系统
  40. //      为每一条线程分配相应的时间片,然后获取时间片之后
  41. //      就开始执行-->操作系统1秒钟有1000次夺回控制权
  42. //  2.Windows属于抢占式操作系统
  43. //      操作系统时时刻刻夺回控制权,在重新进行分配
  44. //  3.冻结状态与解冻状态的体现
  45. //04.处理队列的时候需要将数据更替为HANDLE类型
  46. //05.使用数组构建环形队列比使用链表构建环形队列简单多了
  47. //06.数组正向环形队列相比数组正向队列的好处:
  48. //      删除一个元素之后不需要进行移动,消耗效率

程序片段(17):CircleQueue.h+CircleQueue.c+数组正向环形队列.c

内容概要:01.数组正向环形队列

  1. ///CircleQueue.h
  2. #pragma once
  4. #define DT int
  5. #define EN 10
  7. //01.数组模拟队列:
  8. //  普通队列:使用N个数组元素
  9. //  环形队列:使用N-1个数组元素
  10. typedef struct circleQueue
  11. {
  12.     DT arr[EN];
  13.     int head;
  14.     int tail;
  15. }CircleQueue;
  17. void initCircleQueue(CircleQueue * pCircleQueue);
  19. int circleQueueIsFull(CircleQueue * pCircleQueue);
  21. void enCircleQueue(CircleQueue * pCircleQueue, DT data);
  23. int circleQueueIsEmpty(CircleQueue * pCircleQueue);
  25. void showCircleQueue(CircleQueue * pCircleQueue);
  27. DT circleQueueGetHead(CircleQueue * pCircleQueue);
  29. void deCircleQueue(CircleQueue * pCircleQueue);
  1. ///CircleQueue.c
  2. #include "CircleQueue.h"
  3. #include <stdlib.h>
  4. #include <memory.h>
  5. #include <stdio.h>
  7. void initCircleQueue(CircleQueue * pCircleQueue)
  8. {
  9.     if (NULL == pCircleQueue)
  10.         abort();
  11.     memset((*pCircleQueue).arr, 0, EN * sizeof(DT));
  12.     (*pCircleQueue).tail = (*pCircleQueue).head = 0;
  13. }
  15. int circleQueueIsFull(CircleQueue * pCircleQueue)
  16. {
  17.     if (NULL == pCircleQueue)
  18.         abort();
  19.     if ((*pCircleQueue).head == ((*pCircleQueue).tail + 1) % EN)//满队列
  20.         return 1;
  21.     return 0;
  22. }
  24. void enCircleQueue(CircleQueue * pCircleQueue, DT data)
  25. {
  26.     if (NULL == pCircleQueue)
  27.         abort();
  28.     if (circleQueueIsFull(pCircleQueue))
  29.         return;
  30.     (*pCircleQueue).arr[(*pCircleQueue).tail] = data;//当前填充位置
  31.     (*pCircleQueue).tail = ((*pCircleQueue).tail + 1) % EN;//下个填充位置+保证连续存储
  32. }
  34. int circleQueueIsEmpty(CircleQueue * pCircleQueue)
  35. {
  36.     if (NULL == pCircleQueue)
  37.         abort();
  38.     if ((*pCircleQueue).head == (*pCircleQueue).tail)//空队列
  39.         return 1;
  40.     return 0;
  41. }
  43. void showCircleQueue(CircleQueue * pCircleQueue)
  44. {
  45.     if (NULL == pCircleQueue)
  46.         abort();
  47.     if (circleQueueIsEmpty(pCircleQueue))
  48.         return;
  49.     for (int i = (*pCircleQueue).head; i%EN < (*pCircleQueue).tail; ++i)//i<=>i%EN:这里是环形队列没有出现特殊情况的特点!
  50.     {//数组正向环形队列:1.不确定数组环形队列元素个数+2.不确定环形队列的起始元素和终止元素位置(因此打印无法控制)
  51.         printf("%3d", (*pCircleQueue).arr[i]);
  52.     }
  53.     printf("\n");
  54. }
  56. DT circleQueueGetHead(CircleQueue * pCircleQueue)
  57. {
  58.     if (NULL == pCircleQueue)
  59.         abort();
  60.     if (circleQueueIsEmpty(pCircleQueue))
  61.         return -1;
  62.     return (*pCircleQueue).arr[(*pCircleQueue).head];
  63. }
  65. void deCircleQueue(CircleQueue * pCircleQueue)
  66. {
  67.     if (NULL == pCircleQueue)
  68.         abort();
  69.     if (circleQueueIsEmpty(pCircleQueue))
  70.         return;
  71.     (*pCircleQueue).head = ((*pCircleQueue).head + 1) % EN;
  72. }
  1. ///数组正向环形队列.c
  2. #include "CircleQueue.h"
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <Windows.h>
  7. int main01(void)
  8. {
  9.     CircleQueue circleQueue = { 0 };
  10.     initCircleQueue(&circleQueue);
  11.     for (int i = 0; i < 9; ++i)
  12.     {
  13.         enCircleQueue(&circleQueue, i + 1);
  14.         showCircleQueue(&circleQueue);
  15.     }
  16.     while (!circleQueueIsEmpty(&circleQueue))
  17.     {
  18.         printf("%3d \n", circleQueueGetHead(&circleQueue));
  19.         deCircleQueue(&circleQueue);
  20.         showCircleQueue(&circleQueue);
  21.     }
  23.     system("pause");
  24. }
  26. CircleQueue circleQueue = { 0 };
  28. DWORD WINAPI producer(void * p)
  29. {
  30.     printf("生产者第01次执行生产任务! \n");
  31.     int data = 0;
  32.     while (!circleQueueIsFull(&circleQueue))
  33.     {//生产者:一次性补充满库存黁量
  34.         enCircleQueue(&circleQueue, ++data);
  35.         printf("生产者生产了%3d! \n", data);
  36.     }
  37.     Sleep(1000);
  38.     HANDLE event1 = OpenEvent(EVENT_ALL_ACCESS, TRUE, L"producer");
  39.     SetEvent(event1);
  41.     int i = 1;
  42.     while (++i)
  43.     {
  44.         HANDLE event2 = OpenEvent(EVENT_ALL_ACCESS, TRUE, L"consumer");
  45.         WaitForSingleObject(event2, INFINITE);
  46.         printf("生产者第%02d次执行生产任务! \n", i);
  47.         while (!circleQueueIsFull(&circleQueue))
  48.         {
  49.             enCircleQueue(&circleQueue, ++data);
  50.             printf("生产者生产了%3d! \n", data);
  51.         }
  52.         Sleep(1000);
  53.         SetEvent(event1);
  54.     }
  56.     return 0;
  57. }
  59. DWORD WINAPI consumer(void * p)
  60. {
  61.     int i = 0;
  62.     while (++i)
  63.     {
  64.         HANDLE event1 = OpenEvent(EVENT_ALL_ACCESS, TRUE, L"producer");
  65.         WaitForSingleObject(event1, INFINITE);
  66.         printf("消费者第%02d次执行消费任务! \n", i);
  67.         int num = 9;
  68.         for (int j = 0; j < num; ++j)
  69.         {
  70.             if (!circleQueueIsEmpty(&circleQueue))
  71.             {
  72.                 printf("消费者消费了%3d! \n", circleQueueGetHead(&circleQueue));
  73.                 deCircleQueue(&circleQueue);
  74.             }
  75.         }
  76.         Sleep(1000);
  77.         HANDLE event2 = OpenEvent(EVENT_ALL_ACCESS, TRUE, L"consumer");
  78.         SetEvent(event2);
  79.     }
  80.     return 0;
  81. }
  83. int main02(void)
  84. {
  85.     HANDLE event1 = CreateEvent(NULL, FALSE, FALSE, L"producer");
  86.     HANDLE event2 = CreateEvent(NULL, FALSE, FALSE, L"consumer");
  88.     HANDLE threadArr[2] = { 0 };
  89.     threadArr[0] = CreateThread(NULL, 0, producer, NULL, 0, NULL);
  90.     threadArr[1] = CreateThread(NULL, 0, consumer, NULL, 0, NULL);
  91.     //WaitForSingleObject(producer, INFINITE);//可以直接等待单个线程任务执行结束以后!
  92.     WaitForMultipleObjects(2, threadArr, TRUE, INFINITE);
  94.     CloseHandle(event1);
  95.     system("pause");
  96. }
  98. //01.消费者不管买走多少,都需要将存储结构塞满
  99. //  紧缺产品:针对于畅销产品的库存解决方案
  100. //      随时保持库存充足
  101. //  停滞产品:针对于停滞产品的库存解决方案
  102. //      在满足市场供需的情况之下,库存越少越好
  103. //02.Scanf不是一个线程安全的函数
  104. //  1.所以需要手动进行安全检查
  105. //  2.它也是系统出现漏洞的原因之一
  106. //03.防止进栈压栈冲突:延迟
  107. //  互锁:不要让生产者边生产而消费者边消费
  108. //  解决:生产者完成之后消费者进行消费
  109. //注:以上情况不符合现实情况,现实情况之下需要解决多线程异步并发访问冲突问题
  110. //04.生产者&消费者:
  111. //  1.环形队列的仓库,保证这个库存-->生产的是紧缺产品(随时满足库存量)
  112. //  2.库存一定需要填满(针对于畅销紧缺产品)
  113. //05.工厂设计模式:
  114. //  1.同时生产多个产品-->产品&线程开辟-->平衡调度线程
  115. //      工厂:多线程
  116. //  2.前台卖货:平衡调度
  117. //      库存控制,畅销与非畅销
  118. //  3.消费者消费:千变万化
  119. //注:区分(生产者与消费者)和(工厂)两种设计模式的区别:
  120. //  生产者与消费者:单产品
  121. //  工厂:多产品
  122. //06.链式队列(无线)&栈(有限)
  123. //  服务器几十万几百万的多线程操作
  124. //07.内存数据库:
  125. //  1.所有数据都载入内存-->发出请求
  126. //  2.文件载入内存
  127. //  3.消费者提出(需求),生产者进行(生产)
  128. //  4.线程不断的进行加载
  129. //  5.防止多线程并发访问
  130. //  6.迁移到CGI: 手机查询
  131. //  7.多线程与队列问题-->稳定与不稳定

程序片段(18):Queue.h+Queue.c+Main.c

内容概要:02.链表反向队列

  1. ///Queue.h
  2. #pragma once
  4. #define DT int
  6. typedef struct node
  7. {
  8.     DT data;
  9.     struct node * pNext;
  10. }Node;
  12. void initQueue(Node ** ppQueue);
  14. void enQueue(Node ** ppQueue, DT data);
  16. void showQueue(Node * pQueue);
  18. DT queueGetHead(Node * pQueue);
  20. void deQueue(Node ** ppQueue);
  1. ///Queue.c
  2. #include "Queue.h"
  3. #include <stdlib.h>
  4. #include <stdio.h>
  6. void initQueue(Node ** ppQueue)
  7. {
  8.     if (NULL == ppQueue)
  9.         abort();
  10.     *ppQueue = NULL;
  11. }
  13. void enQueue(Node ** ppQueue, DT data)
  14. {
  15.     if (NULL == ppQueue)//无队列
  16.         abort();
  17.     Node * pNew = (Node *)malloc(sizeof(Node));
  18.     pNew->data = data;
  19.     pNew->pNext = NULL;
  20.     if (NULL == *ppQueue)//空队列
  21.     {
  22.         *ppQueue = pNew;
  23.         return;
  24.     }
  25.     pNew->pNext = *ppQueue;
  26.     *ppQueue = pNew;
  27. }
  29. void showQueue(Node * pQueue)
  30. {
  31.     if (NULL == pQueue)
  32.         return;
  33.     for (Node * pTmp = pQueue; NULL != pTmp; pTmp = pTmp->pNext)
  34.     {
  35.         printf("%3d", pTmp->data);
  36.     }
  37.     printf("\n");
  38. }
  40. DT queueGetHead(Node * pQueue)
  41. {
  42.     if (NULL == pQueue)
  43.         abort();
  44.     Node * pTmp = pQueue;
  45.     while (NULL != pTmp->pNext)
  46.     {
  47.         pTmp = pTmp->pNext;
  48.     }
  49.     return pTmp->data;
  50. }
  52. void deQueue(Node ** ppQueue)
  53. {
  54.     if (NULL == ppQueue)
  55.         abort();
  56.     if (NULL == *ppQueue)
  57.         return;
  58.     if (NULL == (*ppQueue)->pNext)
  59.     {
  60.         free(*ppQueue);
  61.         *ppQueue = NULL;
  62.         return;
  63.     }
  64.     Node * pTmp = *ppQueue;
  65.     while (NULL != pTmp->pNext->pNext)
  66.     {
  67.         pTmp = pTmp->pNext;
  68.     }
  69.     free(pTmp->pNext);
  70.     pTmp->pNext = NULL;
  71. }
  1. ///Main.c
  2. #include "Queue.h"
  3. #include <stdlib.h>
  4. #include <Windows.h>
  6. //01.链表反向队列:
  7. //  全局变量:用作跨线程通信变量
  8. Node * pQueue = NULL;
  10. //02.生产者消费者模式之生产者:
  11. //  1.时时刻刻盯着链表反向队列结构
  12. //  2.区分:畅销产品与非畅销产品
  13. //注:避免过度消耗资源的情况发生
  14. DWORD WINAPI producer(void * p)
  15. {//非畅销产品
  16.     int i = 0;
  17.     while (++i)
  18.     {
  19.         if (NULL == pQueue)
  20.         {
  21.             enQueue(&pQueue, i);
  22.             printf("生产者生产了产品%3d! \n", i);
  23.         }
  24.         Sleep(1000);
  25.     }
  26.     return 0;
  27. }
  29. DWORD WINAPI consumer(void * p)
  30. {
  31.     int i = 0;
  32.     while (++i)
  33.     {
  34.         MessageBoxA(0, "wait", "consumer", 0);
  35.         printf("消费者消费了%3d! \n", queueGetHead(pQueue));
  36.         deQueue(&pQueue);
  37.     }
  38.     return 0;
  39. }
  41. int main01(void)
  42. {
  43.     HANDLE threadArr[2] = { 0 };
  44.     threadArr[0] = CreateThread(NULL, 0, producer, NULL, 0, NULL);
  45.     threadArr[1] = CreateThread(NULL, 0, consumer, NULL, 0, NULL);
  46.     WaitForMultipleObjects(2, threadArr, TRUE, INFINITE);
  48.     system("pause");
  49. }
  51. //01.生产者与消费者(设计模式):
  52. //  1.链表反向队列:作为流水线
  53. //      数组(正向&反向)队列&数组(正向&反向)环形队列&链表(正向&反向)队列
  54. //  2.线程结构:生产者&消费者
  55. //  3.流程原理:
  56. //      (1).当流水线为空的时候,生产者生产
  57. //      (2).生产者:非畅销&畅销(视具体情况而定)
  58. //      (3).消费者:手动控制,可以获取任意个数
  59. //          设计模式:看不明白的主要原因是因为多线程
  60. //          单线程没有意义,多线程才有意义
  61. //02.生产者&消费者:
  62. //  1.生产"紧缺"产品&生产"非紧缺"产品
  63. //  2.生产者&消费者所做事情:
  64. //      (1),生产者时时刻刻检测数据结构是否已经填充满了
  65. //          没有满需要插入数据-->链式队列:锁定数目就行了(防止无限仓库产生)
  66. //          理论上都不推荐使用链式队列:因为过渡消耗资源
  67. //          -->链式栈不存在满的情况:可以进行无限拓展
  68. //      (2).用于软件开发的两种情况:
  69. //          1).生产&消费分开做
  70. //          2).工厂模式更加复杂(不同类型的生产者与消费者模式)
  71. //03.理解生产者与消费者
  72. //  1.生产者需要保证至少有一个
  73. //  2.消费者的消费情况是随机消费的
  74. //  3.消费者需要配合生产着
  75. //      一个入队,一个出队[消费者的消费是个不确定的数据]
  76. //  4.线程通信中间使用最多的是什么?
  77. //          事件&互斥量&信号量

程序片段(19):Queue.h+Queue.c+01.Event通信(生产者消费者).cpp+02.Semaphore通信(生产者消费者).c

内容概要:03.生产者与消费者模式

  1. ///Queue.h
  2. #pragma once
  4. #define DT int
  6. typedef struct node
  7. {
  8.     DT data;
  9.     struct node * pNext;
  10. }Node;
  12. void initQueue(Node ** ppQueue);
  14. void enQueue(Node ** ppQueue, DT data);
  16. void showQueue(Node * pQueue);
  18. DT queueGetHead(Node * pQueue);
  20. void deQueue(Node ** ppQueue);
  1. ///Queue.c
  2. #include "Queue.h"
  3. #include <stdlib.h>
  4. #include <stdio.h>
  6. void initQueue(Node ** ppQueue)
  7. {
  8.     if (NULL == ppQueue)
  9.         abort();
  10.     *ppQueue = NULL;
  11. }
  13. void enQueue(Node ** ppQueue, DT data)
  14. {
  15.     if (NULL == ppQueue)//无队列
  16.         abort();
  17.     Node * pNew = (Node *)malloc(sizeof(Node));
  18.     pNew->data = data;
  19.     pNew->pNext = NULL;
  20.     if (NULL == *ppQueue)//空队列
  21.     {
  22.         *ppQueue = pNew;
  23.         return;
  24.     }
  25.     pNew->pNext = *ppQueue;
  26.     *ppQueue = pNew;
  27. }
  29. void showQueue(Node * pQueue)
  30. {
  31.     if (NULL == pQueue)
  32.         return;
  33.     for (Node * pTmp = pQueue; NULL != pTmp; pTmp = pTmp->pNext)
  34.     {
  35.         printf("%3d", pTmp->data);
  36.     }
  37.     printf("\n");
  38. }
  40. DT queueGetHead(Node * pQueue)
  41. {
  42.     if (NULL == pQueue)
  43.         abort();
  44.     Node * pTmp = pQueue;
  45.     while (NULL != pTmp->pNext)
  46.     {
  47.         pTmp = pTmp->pNext;
  48.     }
  49.     return pTmp->data;
  50. }
  52. void deQueue(Node ** ppQueue)
  53. {
  54.     if (NULL == ppQueue)
  55.         abort();
  56.     if (NULL == *ppQueue)
  57.         return;
  58.     if (NULL == (*ppQueue)->pNext)
  59.     {
  60.         free(*ppQueue);
  61.         *ppQueue = NULL;
  62.         return;
  63.     }
  64.     Node * pTmp = *ppQueue;
  65.     while (NULL != pTmp->pNext->pNext)
  66.     {
  67.         pTmp = pTmp->pNext;
  68.     }
  69.     free(pTmp->pNext);
  70.     pTmp->pNext = NULL;
  71. }
  1. ///01.Event通信(生产者消费者).cpp
  2. #include "Queue.h"
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <Windows.h>
  7. Node * pQueue = NULL;
  9. DWORD WINAPI producer(void * p)
  10. {
  11.     enQueue(&pQueue, 1);
  12.     int i = 1;
  13.     while (++i)
  14.     {
  15.         HANDLE event1 = OpenEvent(EVENT_ALL_ACCESS, TRUE, L"consumer");
  16.         WaitForSingleObject(event1, INFINITE);
  17.         printf("生产者生产了%3d! \n", i);
  18.         enQueue(&pQueue, i);
  19.     }
  20.     return 0;
  21. }
  23. DWORD WINAPI consumer(void * p)
  24. {
  25.     int i = 0;
  26.     while (++i)
  27.     {
  28.         MessageBoxA(0, "wait", "wait", 0);
  29.         printf("消费者消费了%3d! \n", queueGetHead(pQueue));
  30.         deQueue(&pQueue);
  31.         HANDLE event1 = OpenEvent(EVENT_ALL_ACCESS, TRUE, L"consumer");
  32.         SetEvent(event1);
  33.     }
  34.     return 0;
  35. }
  37. int main01(void)
  38. {
  39.     HANDLE event1 = CreateEvent(NULL, FALSE, FALSE, L"consumer");
  41.     HANDLE threadArr[2] = { 0 };
  42.     threadArr[0] = CreateThread(NULL, 0, producer, NULL, 0, NULL);
  43.     threadArr[1] = CreateThread(NULL, 0, consumer, NULL, 0, NULL);
  44.     WaitForMultipleObjects(2, threadArr, TRUE, INFINITE);
  46.     CloseHandle(event1);
  47.     system("pause");
  48.     return 1;
  49. }
  51. //01.消费完成之后设置事件的触发
  52. //02.每秒钟进行检测,浪费资源
  53. //03.事件的关键步骤:
  54. //  CloseHandle(event);
  55. //04.在一个线程里面不需要死循环:
  56. //  因为它在这儿i不断的进行自增,增加的次数不确定
  57. //05.事件通信&信号量通信
  1. ///02.Semaphore通信(生产者消费者).c
  2. #include "Queue.h"
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <Windows.h>
  7. Node * pQueue = NULL;
  9. DWORD WINAPI producer(void * p)
  10. {
  11.     HANDLE sema = OpenSemaphoreA(SEMAPHORE_ALL_ACCESS, TRUE, "consumer");
  12.     enQueue(&pQueue, 1);
  13.     int i = 1;
  14.     while (++i)
  15.     {
  16.         WaitForSingleObject(sema, INFINITE);
  17.         printf("生产者生产了%3d! \n", i);
  18.         enQueue(&pQueue, i);
  19.     }
  20.     return 0;
  21. }
  23. DWORD WINAPI consumer(void * p)
  24. {
  25.     HANDLE sema = OpenSemaphoreA(SEMAPHORE_ALL_ACCESS, TRUE, "consumer");
  26.     int i = 0;
  27.     while (++i)
  28.     {
  29.         MessageBoxA(0, "wait", "consumer", 0);
  30.         printf("消费者消费了%3d! \n", queueGetHead(pQueue));
  31.         deQueue(&pQueue);
  32.         ReleaseSemaphore(sema, 1, NULL);
  33.     }
  34.     return 0;
  35. }
  37. int main02(void)
  38. {
  39.     HANDLE sema = CreateSemaphoreA(NULL, 0, 1, "consumer");
  41.     HANDLE threadArr[2] = { 0 };
  42.     threadArr[0] = CreateThread(NULL, 0, producer, NULL, 0, NULL);
  43.     threadArr[1] = CreateThread(NULL, 0, consumer, NULL, 0, NULL);
  44.     WaitForMultipleObjects(2, threadArr, TRUE, INFINITE);
  46.     CloseHandle(sema);
  47.     system("pause");
  48. }
  50. //01.信号量解决生产者与消费者问题:
  51. //  C++称之为工厂设计模式
  52. //02.事件-->互斥量解决线程通信问题:
  53. //  事件-->信号量问题分析
  54. //03.设计模式结合多线程比较好理解
  55. //  两个变量之间的双方通信规则

20160227.CCPP体系详解(0037天)的更多相关文章

  1. 20160129.CCPP体系详解(0008天)

    程序片段(01):函数.c+call.c+测试.cpp 内容概要:函数 ///函数.c #include <stdio.h> #include <stdlib.h> //01. ...

  2. 20160226.CCPP体系详解(0036天)

    程序片段(01):01.多线程.c+02.多线程操作.c 内容概要:多线程 ///01.多线程.c #include <stdio.h> #include <stdlib.h> ...

  3. 20160208.CCPP体系详解(0018天)

    程序片段(01):main.c 内容概要:PointWithOutInit #include <stdio.h> #include <stdlib.h> //01.野指针详解: ...

  4. 20160206.CCPP体系详解(0016天)

    代码片段(01):.指针.c+02.间接赋值.c 内容概要:内存 ///01.指针 #include <stdio.h> #include <stdlib.h> //01.取地 ...

  5. 20160205.CCPP体系详解(0015天)

    程序片段(01):01.杨辉三角.c 内容概要:杨辉三角 #include <stdio.h> #include <stdlib.h> #define N 10 //01.杨辉 ...

  6. 20160204.CCPP体系详解(0014天)

    程序片段(01):define.h+data.h&data.c+control.h&control.c+view.h&view.c+AI.h&AI.c+main.c 内 ...

  7. 20160203.CCPP体系详解(0013天)

    程序片段(01):数组.c+02.数组初始化语法.c 内容概要:数组 ///01.数组.c #include <stdio.h> #include <stdlib.h> //0 ...

  8. 20160128.CCPP体系详解(0007天)

    以下内容有所摘取,进行了某些整理和补充 论浮点数的存储原理:float浮点数与double浮点数的二进制存储原理–>阶码 浮点数转二进制 1.整数int类型和浮点数float类型都是占用4个字节 ...

  9. 20160127.CCPP体系详解(0006天)

    程序片段(01):msg.c 内容概要:线程概念 #include <stdio.h> #include <stdlib.h> #include <Windows.h&g ...

随机推荐

  1. 框架学习之Spring(一IOC)----HelloWrod

    一.概述 Spring是一个开源框架,它的核心是控制反转(IOC)和面向切面(AOP).简单来说,Spring是一个分层的JavaSE/EEfull-stack(一站式)轻量级开源框架. EE 开发分 ...

  2. POJ-3169 Layout---差分约束系统+Bellman

    题目链接: https://vjudge.net/problem/POJ-3169 题目大意: 一些母牛按序号排成一条直线.有两种要求,A和B距离不得超过X,还有一种是C和D距离不得少于Y,问可能的最 ...

  3. JSON定义

    如果我们要在不同的编程语言之间传递对象,就必须把对象序列化为标准格式,比如xml,但更好的方法是序列化为JSON,因为JSON表示出来就是一个字符串,可以被所有语言读取,也可以方便地存储到磁盘或者通过 ...

  4. github git 在GitHub上创建项目并将本地项目push到网站上

    众所周知,git是与svn类似的版本控制系统,git的去中心化.分布式等的优点,在不久将来用户量大有可能超过svn, 常见的代码托管网站有GitHub,coding.net, gitee.com 码云 ...

  5. c++简单线程池实现

    线程池,简单来说就是有一堆已经创建好的线程(最大数目一定),初始时他们都处于空闲状态,当有新的任务进来,从线程池中取出一个空闲的线程处理任务,然后当任务处理完成之后,该线程被重新放回到线程池中,供其他 ...

  6. 列表（list）之三 -如何较为均匀的将任意字符串按指定组数分组，方差最少

    当字符串的长度不是份数的整数倍时如何均匀地分割,例如:长度为11的字符串要分割成4份,有很多种分法,比如3, 3, 3, 2(前3个字符一份,中间3个一份,再中间3个一份,最后2个一份)这种是比较均匀 ...

  7. Python中if __name__ == "__main__": 的理解

    1.在很多python脚本中在最后的部分会执行一个判断语句if __name__ == "__main__:",之后还可能会有一些执行语句.那添加这个判断的目的何在? 在pytho ...

  8. Spring Boot 之Hello Word

    Spring Boot官网:http://projects.spring.io/spring-boot/ 环境准备:maven 3.3.5.jdk8.Idea 1.创建maven项目工程 2.引入st ...

  9. “百度杯”CTF比赛 九月场_123（文件备份，爆破，上传）

    题目在i春秋ctf训练营 翻看源码,发现提示: 打开user.php,页面一片空白,参考大佬的博客才知道可能会存在user.php.bak的备份文件,下载该文件可以得到用户名列表 拿去burp爆破: ...

  10. day 1——字典树练习

    cojs 173. 词链 ★☆   输入文件:link.in   输出文件:link.out   简单对比时间限制:1 s   内存限制:128 MB [问题描述]给定一个仅包含小写字母的英文单词表, ...