读写者问题

image.png
image.png
image.png
image.png
image.png
Java参考

C++代码实现

  1. #include <iostream>
  2.  #include <windows.h>
  3.  #include <fstream>
  4.  #define MAX_THREAD_NUM 64 //最大线程数
  5.  #define INTE_PER_SEC 1000 //每秒时钟中断的数目
  6.  #define MAX_FILE_NUM 32 //最大文件数目数
  7.  #define MAX_STR_LEN 32 //字符串的长度
  8.  using namespace std;
  9.  int readcount = 0; //读者数目
  10.  int writecount = 0; //写者数目
  11.  CRITICAL_SECTION RP_Write; //临界资源
  12.  CRITICAL_SECTION cs_Write;
  13.  CRITICAL_SECTION cs_Read;
  14.  struct ThreadInfo {
  15.      int serial; //线程序号
  16.      char entity; //线程类别(判断是读者还是写者线程)
  17.      double delay; //线程延迟时间
  18.      double persist; //线程读写操作时间
  19.  };
  21.  //读者优先<--->读者线程//
  22.  void RP_ReaderThread(void *p) //P:读者线程信息
  23.  {
  24.      //互斥变量
  25.      HANDLE h_Mutex;
  26.      h_Mutex = OpenMutex(MUTEX_ALL_ACCESS, FALSE, "mutex_for_readcount");
  27.      DWORD wait_for_mutex; //等待互斥变量所有权
  28.      DWORD m_delay; //延迟时间
  29.      DWORD m_persist; //读文件持续时间
  30.      int m_serial; //线程序号
  31.      // 从参数中获得信息
  32.      m_serial = ((ThreadInfo *) (p))->serial;
  33.      m_delay = (DWORD) (((ThreadInfo *) (p))->delay * INTE_PER_SEC);
  34.      m_persist = (DWORD) (((ThreadInfo *) (p))->persist * INTE_PER_SEC);
  35.      Sleep(m_delay); //延迟等待
  36.      cout << "Reader thread " << m_serial << " sents the reading require !" << endl;
  37.      //等待互斥信号,保证对 ReadCount 的访问,修改互斥
  38.      wait_for_mutex = WaitForSingleObject(h_Mutex, -1);
  39.      //读者数目增加
  40.      readcount++;
  41.      if (readcount == 1) {
  42.          //第一个读者,等待资源
  43.          EnterCriticalSection(&RP_Write);
  44.      }
  45.      ReleaseMutex(h_Mutex); //释放互斥信
  46.      //读文件
  47.      cout << "Reader thread " << m_serial << " begins to read file !" << endl;
  48.      Sleep(m_persist);
  49.      //退出线程
  50.      cout << "Reader thread " << m_serial << " finished reading file !" << endl;
  51.      //等待互斥信号,保证对 ReadCount 的访问,修改互斥
  52.      wait_for_mutex = WaitForSingleObject(h_Mutex, -1);
  53.      //读者数目减少
  54.      readcount--;
  55.      if (readcount == 0) {
  56.          //如果所有的读者读完,唤醒写者
  57.          LeaveCriticalSection(&RP_Write);
  58.      }
  59.      ReleaseMutex(h_Mutex); //释放互斥信号
  60.  }
  62.  //P:写者线程信息
  63.  void RP_WriterThread(void *p) {
  64.      DWORD m_delay; //延迟时间
  65.      DWORD m_persist; //写文件持续时间
  66.      int m_serial; //线程序号
  67.      // 从参数中获得信息
  68.      m_serial = ((ThreadInfo *) (p))->serial;
  69.      m_delay = (DWORD) (((ThreadInfo *) (p))->delay * INTE_PER_SEC);
  70.      m_persist = (DWORD) (((ThreadInfo *) (p))->persist * INTE_PER_SEC);
  71.      Sleep(m_delay);
  72.      cout << "Writer thread " << m_serial << " sents the writing require !" << endl;
  73.      //等待资源
  74.      EnterCriticalSection(&RP_Write);
  75.      //写文件
  76.      cout << "Writer thread " << m_serial << " begins to write file !" << endl;
  77.      Sleep(m_persist);
  78.      //退出线程
  79.      cout << "Writer thread " << m_serial << " finished writing file !" << endl;
  80.      //释放资源
  81.      LeaveCriticalSection(&RP_Write);
  82.  }
  84.  //读者优先处理函数
  85.  void ReaderPriority(const char *fileName) {
  86.      DWORD n_thread = 0; //线程数目
  87.      DWORD thread_ID; //线程 ID
  88.      DWORD wait_for_all; //等待所有线程结束
  89.      //互斥对象
  90.      HANDLE h_Mutex;
  91.      h_Mutex = CreateMutex(NULL, FALSE, "mutex_for_readcount");
  92.      //线程对象的数组
  93.      HANDLE h_Thread[MAX_THREAD_NUM];
  94.      ThreadInfo thread_info[MAX_THREAD_NUM];
  95.      readcount = 0; //初始化 readcount
  96.      InitializeCriticalSection(&RP_Write); //初始化临界区
  97.      ifstream inFile;
  98.      inFile.open(fileName);
  99.      if (!inFile) {
  100.          cout << "文件打开失败!" << endl;
  101.      }
  102.      cout << "读者优先:" << endl;
  103.      while (inFile) {
  104.          //读入每一个读者,写者的信息
  105.          inFile >> thread_info[n_thread].serial;
  106.          inFile >> thread_info[n_thread].entity;
  107.          inFile >> thread_info[n_thread].delay;
  108.          inFile >> thread_info[n_thread++].persist;
  109.          inFile.get();
  110.      }
  111.      for (int i = 0; i < (int) (n_thread); i++) {
  112.          if (thread_info[i].entity == 'R') {
  113.              //创建读者进程
  114.              h_Thread[i] = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) (RP_ReaderThread), &thread_info[i], 0,
  115.                                         &thread_ID);
  116.          } else {
  117.              //创建写线程
  118.              h_Thread[i] = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) (RP_WriterThread), &thread_info[i], 0,
  119.                                         &thread_ID);
  120.          }
  121.      }
  123.      //等待所有的线程结束
  124.      wait_for_all = WaitForMultipleObjects(n_thread, h_Thread, TRUE, -1);
  125.      cout << "All reader and writer have finished operating !" << endl;
  126.  }
  129.  //写者优先---读者线程
  130.  //P:读者线程信息
  131.  void WP_ReaderThread(void *p) {
  132.      HANDLE print;
  133.      print = CreateMutex(NULL, FALSE, LPCTSTR("mutex_for_print"));
  134.      //互斥变量
  135.      HANDLE h_Mutex1;
  136.      h_Mutex1 = OpenMutex(MUTEX_ALL_ACCESS, FALSE, "mutex1");
  137.      HANDLE h_Mutex2;
  138.      h_Mutex2 = OpenMutex(MUTEX_ALL_ACCESS, FALSE, "mutex2");
  139.      DWORD wait_for_mutex1; //等待互斥变量所有权
  140.      DWORD wait_for_mutex2;
  141.      DWORD m_delay; //延迟时间
  142.      DWORD m_persist; //读文件持续时间
  143.      int m_serial; //线程的序号
  144.      //从参数中得到信息
  145.      m_serial = ((ThreadInfo *) (p))->serial;
  146.      m_delay = (DWORD) (((ThreadInfo *) (p))->delay * INTE_PER_SEC);
  147.      m_persist = (DWORD) (((ThreadInfo *) (p))->persist * INTE_PER_SEC);
  148.      Sleep(m_delay); //延迟等待
  149.      DWORD wait_to_print = WaitForSingleObject(print, -1);
  150.      cout << "Reader thread " << m_serial << " sents the reading require !" << endl;
  151.      ReleaseMutex(print);
  152.      wait_for_mutex1 = WaitForSingleObject(h_Mutex1, -1);
  153.      //读者进去临界区
  154.      EnterCriticalSection(&cs_Read);
  155.      //阻塞互斥对象 Mutex2,保证对 readCount 的访问和修改互斥
  156.      wait_for_mutex2 = WaitForSingleObject(h_Mutex2, -1);
  157.      //修改读者的数目
  158.      readcount++;
  159.      if (readcount == 1) {
  160.          // 如果是第 1 个读者,等待写者写完
  161.          EnterCriticalSection(&cs_Write);
  162.      }
  163.      ReleaseMutex(h_Mutex2);// 释放互斥信号 Mutex2
  164.      //让其他读者进去临界区
  165.      LeaveCriticalSection(&cs_Read);
  166.      ReleaseMutex(h_Mutex1);
  167.      //读文件
  168.      wait_to_print = WaitForSingleObject(print, -1);
  169.      cout << "Reader thread " << m_serial << " begins to read file !" << endl;
  170.      ReleaseMutex(print);
  171.      Sleep(m_persist);
  172.      //退出线程
  173.      wait_to_print = WaitForSingleObject(print, -1);
  174.      cout << "Reader thread " << m_serial << " finished reading file !" << endl;
  175.      ReleaseMutex(print);
  176.      //阻塞互斥对象 Mutex2,保证对 readcount 的访问,修改互斥
  177.      wait_for_mutex1 = WaitForSingleObject(h_Mutex2, -1);
  178.      readcount--;
  179.      if (readcount == 0) {
  180.          //最后一个读者,唤醒写者
  181.          LeaveCriticalSection(&cs_Write);
  182.      }
  183.      ReleaseMutex(h_Mutex2); //释放互斥信号
  184.  }
  187.  //写者优先---写者线程
  188.  //P:写者线程信息
  189.  void WP_WriterThread(void *p) {
  191.      DWORD wait_for_mutex3; //互斥变量
  192.      DWORD m_delay; //延迟时间
  193.      DWORD m_persist; //读文件持续时间
  194.      int m_serial; //线程序号
  195.      HANDLE h_Mutex3;
  196.      h_Mutex3 = OpenMutex(MUTEX_ALL_ACCESS, FALSE, "mutex3");
  197.      //从参数中获得信息
  198.      m_serial = ((ThreadInfo *) (p))->serial;
  199.      m_delay = (DWORD) (((ThreadInfo *) (p))->delay * INTE_PER_SEC);
  200.      m_persist = (DWORD) (((ThreadInfo *) (p))->persist * INTE_PER_SEC);
  201.      Sleep(m_delay); //延迟等待
  202.      cout << "Writer thread " << m_serial << " sents the writing require !" << endl;
  203.      wait_for_mutex3 = WaitForSingleObject(h_Mutex3, -1);
  204.      writecount++; //修改写者数目
  205.      if (writecount == 1) {
  206.          EnterCriticalSection(&cs_Read);
  207.      }
  208.      ReleaseMutex(h_Mutex3);
  209.      EnterCriticalSection(&cs_Write);
  210.      cout << "Writer thread " << m_serial << " begins to write file !" << endl;
  211.      Sleep(m_persist);
  212.      cout << "Writer thread " << m_serial << " finished writing file !" << endl;
  213.      LeaveCriticalSection(&cs_Write);
  214.      wait_for_mutex3 = WaitForSingleObject(h_Mutex3, -1);
  215.      writecount--;
  216.      if (writecount == 0) {
  217.          LeaveCriticalSection(&cs_Read);
  218.      }
  219.      ReleaseMutex(h_Mutex3);
  220.  }
  224.  //写者优先处理函数
  225.  // fileName:文件名
  226.  void WriterPriority(const char *fileName) {
  227.      DWORD n_thread = 0;
  228.      DWORD thread_ID;
  229.      DWORD wait_for_all;
  230.      HANDLE h_Mutex1;
  231.      h_Mutex1 = CreateMutex(NULL, FALSE, "mutex1");
  232.      HANDLE h_Mutex2;
  233.      h_Mutex2 = CreateMutex(NULL, FALSE, "mutex2");
  234.      HANDLE h_Mutex3;
  235.      h_Mutex3 = CreateMutex(NULL, FALSE, "mutex3");
  236.      HANDLE h_Thread[MAX_THREAD_NUM];
  237.      ThreadInfo thread_info[MAX_THREAD_NUM];
  238.      readcount = 0;
  239.      writecount = 0;
  240.      InitializeCriticalSection(&cs_Write);
  241.      InitializeCriticalSection(&cs_Read);
  242.      ifstream inFile;
  243.      inFile.open(fileName);
  244.      cout << "Writer Priority:" << endl;
  245.      while (inFile) {
  246.          inFile >> thread_info[n_thread].serial;
  247.          inFile >> thread_info[n_thread].entity;
  248.          inFile >> thread_info[n_thread].delay;
  249.          inFile >> thread_info[n_thread++].persist;
  250.          inFile.get();
  251.      }
  252.      for (int i = 0; i < (int) (n_thread); i++) {
  253.          if (thread_info[i].entity == 'R') {
  254.              //创建读者进程
  255.              h_Thread[i] = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) (WP_ReaderThread), &thread_info[i], 0,
  256.                                         &thread_ID);
  257.          } else if (thread_info[i].entity == 'W') {
  258.              //创建写线程
  259.              h_Thread[i] = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) (WP_WriterThread), &thread_info[i], 0,
  260.                                         &thread_ID);
  261.          }
  262.      }
  263.      //等待所有的线程结束
  264.      wait_for_all = WaitForMultipleObjects(n_thread, h_Thread, TRUE, -1);
  265.      cout << "All reader and writer have finished operating !" << endl;
  266.  }
  270.  //主函数
  271.  int main() {
  273.      const char *file = "F:\\Study\\C++\\OS\\WR_EXP\\data.txt";
  274.      char ch;
  275.      cout<<endl;
  276.      while (1) {
  277.          cout << "--读者与写者问题--" << endl;
  278.          cout << "---------------" << endl;
  279.          cout << "| 1、读者优先 |" << endl;
  280.          cout << "| 2、写者优先 |" << endl;
  281.          cout << "| 3、退出    |" << endl;
  282.          cout << "---------------" << endl;
  283.          printf("请选择(1,2,3): ");
  284.          do {
  285.              ch = (char) getchar();
  286.          } while (ch != '1' && ch != '2' && ch != '3');
  287.          system("cls"); //执行清屏幕命令
  288.          switch (ch) {
  289.              case '1':
  290.                  ReaderPriority(file);
  291.                  break;
  292.              case '2':
  293.                  WriterPriority(file);
  294.                  break;
  295.              case '3':
  296.                  return 0;
  297.          }
  298.          cout << endl << "按任意键继续..." << endl;
  299.          getchar();
  300.          system("cls");
  301.      }
  302.      return 0;
  303.  }