4

使用示例我创建了两个进程一个主进程和一个从属进程，以测试共享内存 IPC。主服务器创建共享内存并开始写入，并且在从属连接一段时间后，这正在工作，但是一旦从属连接它不会接收/获取主写入共享内存的所有数据。

主代码如下所示：

    typedef struct custom_data_s {
      最小;
      最大整数；
      /* 用以分享 */
      pthread_mutex_t ipc_mutex；
      pthread_cond_t ipc_condvar；
    } custom_data_t;

    诠释主要（无效）{
      int fd = -1;
      custom_data_t *this_custom_data;
      pthread_mutexattr_t 互斥属性；
      pthread_condattr_t cond_attr;

      fd = shm_open("/A_CUSTOM_DATA", O_RDWR | O_CREAT | O_EXCL , (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH));
      如果（fd == -1）{
        printf("错误 fd %d %s\n",fd,strerror(errno));
      }

     if (ftruncate (fd,sizeof(custom_data_t)) == -1) {
        printf("错误 trucate fd %d %s\n",fd,strerror(errno));
        退出（1）；
      }

      this_custom_data = (custom_data_t *) mmap(NULL, sizeof(custom_data_t), PROT_READ | PROT_WRITE , MAP_SHARED ,fd ,0);
      如果（this_custom_data ==（custom_data_t *）-1）{
        printf("错误映射 fd %d %s\n",fd,strerror(errno));
        退出（1）；
      }
      关闭（fd）；

      pthread_mutexattr_init(&mutex_attr);
      pthread_mutexattr_setpshared(&mutex_attr, PTHREAD_PROCESS_SHARED);
      pthread_mutex_init(&this_custom_data->ipc_mutex, &mutex_attr);

      pthread_condattr_init(&cond_attr);
      pthread_condattr_setpshared(&cond_attr, PTHREAD_PROCESS_SHARED);
      pthread_cond_init(&this_custom_data->ipc_condvar, &cond_attr);

     对于 (fd=0; fd != 100000; fd++) {
        pthread_mutex_lock(&this_custom_data->ipc_mutex);
        this_custom_data->min = fd;
        this_custom_data->max = fd+5;
        pthread_cond_signal(&this_custom_data->ipc_condvar);
        pthread_mutex_unlock(&this_custom_data->ipc_mutex);
      }
      /* 清理和退出应该检查所有的退出代码*/
      pthread_mutexattr_destroy(&mutex_attr);
      pthread_condattr_destroy(&cond_attr);

      pthread_cond_destroy(&this_custom_data->ipc_condvar);
      pthread_mutex_destroy(&this_custom_data->ipc_mutex);

      if(0 != munmap(this_custom_data, sizeof(custom_data_t))) {
        printf("错误取消映射 %s\n",strerror(errno));
        退出（1）；
      }  
      if (0 != shm_unlink("/A_CUSTOM_DATA")){
        printf("取消链接 %s 时出错\n",strerror(errno));
        退出（1）；
      }
      返回0；
    }

例如 master 在一段时间后从 1 到 10000 开始将 min 和 max 写入共享内存 一旦 slave 连接它应该读取 master 写入的所有数据但是如果在代码中一旦 slave 连接它仍然没有读取所有数据，什么我做错了吗？从站是否应该设置另一个条件变量？我正在尝试学习共享内存，但我认为我做错了什么或不了解互斥锁和共享内存的方式。在从机中，我正在等待设置条件变量，这是从机的代码。

    typedef struct custom_data_s {
      最小;
      最大整数；
      /* 用以分享 */
      pthread_mutex_t ipc_mutex；
      pthread_cond_t ipc_condvar；
    } custom_data_t;

    诠释主要（无效）{
      int fd = -1;
      custom_data_t *this_custom_data_ptr;
      custom_data_t this_data;
      int prv_packet = 0;

      fd = shm_open("/A_CUSTOM_DATA", O_RDWR , (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH));
      如果（fd == -1）{
        printf("错误 fd %d %s\n",fd,strerror(errno));
      }

      if (ftruncate (fd,sizeof(custom_data_t)) == -1) {
        printf("错误 trucate fd %d %s\n",fd,strerror(errno));
        退出（1）；
      }

      this_custom_data_ptr = (custom_data_t *) mmap(NULL, sizeof(custom_data_t), PROT_READ | PROT_WRITE , MAP_SHARED ,fd ,0);
      如果（this_custom_data_ptr ==（custom_data_t *）-1）{
        printf("错误映射 fd %d %s\n",fd,strerror(errno));
        退出（1）；
      }
      关闭（fd）；
    而（1）{
        pthread_mutex_lock(&this_custom_data_ptr->ipc_mutex);
        pthread_cond_wait(&this_custom_data_ptr->ipc_condvar, &this_custom_data_ptr->ipc_mutex);
        memcpy(&this_data, this_custom_data_ptr, sizeof(this_custom_data_ptr));
        如果（prv_packet == 0）{
          printf ("拿到第一");
          prv_packet = this_data.min;
        }
        if ((prv_packet +1) != this_data.min){
          printf ("error prv:%d this:%d\n", prv_packet, this_data.min);
        }
        pthread_mutex_unlock(&this_custom_data_ptr->ipc_mutex);
        prv_packet = this_data.min;
      }
      返回0；
    }

我究竟做错了什么？我如何同步，以便一旦连接了从站，它就不会丢失任何数据，但如果它没有连接，那么主站也不会被阻塞。

4

0 回答 0