Question

我正在使用对Windows API C库的调用来开发C ++类。

我正在使用信号量来完成任务，让我说我有两个过程：

ProcessA有两个信号量：

全局\ processA_receiving_semaphore

全局\ processA_waiting_semaphore

ProcessB有两个信号量：

全局\ processB_receiving_semaphore

全局\ processB_waiting_semaphore

我在每个流程中都有两个主题：

在processA中发送线程：

等待＆＃34; Global \ processB_waiting_semaphore＆＃34;

//做点什么

信号＆＃34;全球\ processB_receiving_semaphore＆＃34;

在processB上接收线程：

等待＆＃34; Global \ processB_receiving_semaphore＆＃34;

//做点什么

信号＆＃34;全球\ processB_waiting_semaphore

我删除了发布＆＃34; Global \ processB_waiting_semaphore＆＃34;的所有代码。但它仍然可以获得。在该信号量上调用WaitForSingleObject总是会立即返回成功等待。我尝试将超时时间设置为0，并且当NOTHING释放时它仍然获取信号量。

接收信号量有initial count = 0和max count = 1，等待信号量有initial count = 1和max count = 1。

在接收信号量上调用WaitForSingleObject可以很好地阻塞，直到它被其他进程释放为止。问题在于等待信号量，我无法弄清楚原因。代码非常大，我确保信号量的名称设置正确。

这是一个常见问题吗？如果您需要更多解释，请发表评论，我将修改帖子。

编辑：添加代码：

接收方信号量：

bool intr_process_comm::create_rcvr_semaphores()
{
  std::cout << "\n  Creating semaphore: " << "Global\\" << this_name << "_rcvr_sem";
  rcvr_sem = CreateSemaphore(NULL, 0, 1, ("Global\\" + this_name + "_rcvr_sem").c_str());

  std::cout << "\n  Creating semaphore: " << "Global\\" << this_name << "_wait_sem";
  wait_sem = CreateSemaphore(NULL, 1, 1, ("Global\\" + this_name + "_wait_sem").c_str());

  return (rcvr_sem && wait_sem);
}

发件人信号量：

// this sender connects to the wait semaphore in the target process
sndr_sem = OpenSemaphore(SEMAPHORE_MODIFY_STATE, FALSE, ("Global\\" + target_name + "_wait_sem").c_str());
// this target connects to the receiver semaphore in the target process
trgt_sem = OpenSemaphore(SEMAPHORE_MODIFY_STATE, FALSE, ("Global\\" + target_name + "_rcvr_sem").c_str());

DWORD intr_process_locking::wait(unsigned long period)
{
   return WaitForSingleObject(sndr_sem, period);
}

void intr_process_locking::signal()
{
   ReleaseSemaphore(trgt_sem, 1, 0);
}

接收线程功能：

void intr_process_comm::rcvr_thread_proc()
{
  while (conn_state == intr_process_comm::opened) {
    try {
      // wait on rcvr_semaphore for an infinite time
      WaitForSingleObject(rcvr_sem, INFINITE);
      if (inner_release) // if the semaphore was released within this process
        return;
      // once signaled by another process, get the message
      std::string msg_str((LPCSTR)hmf_mapview);
      // signal one of the waiters that want to put messages 
      // in this process's memory area
      // 
      // this doesn't change ANYTHING in execution, commented or not..
      //ReleaseSemaphore(wait_sem, 1, 0);

      // put this message in this process's queue
      Msg msg = Msg::from_xml(msg_str);
      if (msg.command == "connection")
        process_connection_message(msg);

      in_messages.enQ(msg);
      //std::cout << "\n  Message: \n"<< msg << "\n";
    }
    catch (std::exception e) {
      std::cout << "\n  Ran into trouble getting the message. Details: " << e.what();
    }
  }
}

发送线程功能：

void intr_process_comm::sndr_thread_proc()
{
  while (conn_state == intr_process_comm::opened ||
    (conn_state == intr_process_comm::closing && out_messages.size() > 0)
    ) {
    // pull a message out of the queue
    Msg msg = out_messages.deQ();

    if (connections.find(msg.destination) == connections.end())
      connections[msg.destination].connect(msg.destination);

    if (connections[msg.destination].connect(msg.destination)
      != intr_process_locking::state::opened) {
      blocked_messages[msg.destination].push_back(msg);
      continue;
    }

    // THIS ALWAYS GETS GETS WAIT_OBJECT_0 RESULT
    DWORD wait_result = connections[msg.destination].wait(wait_timeout);
    if (wait_result == WAIT_TIMEOUT) {  // <---- THIS IS NEVER TRUE
      out_messages.enQ(msg);
      continue;
    }
    // do things here
    // release the receiver semaphore in the other process
    connections[msg.destination].signal();
  }
}

澄清一些事情：

发件人中的

trgt_sem是接收者中的rcvr_sem。

`sndr_sem＆＃39;在发件人中是＆＃39; wait_sem＆＃34;在接收器中。

Answer 1

用于调用WaitForSingleObject并使用一些句柄：

句柄必须具有 SYNCHRONIZE 访问权限。

但您只能使用 SEMAPHORE_MODIFY_STATE 访问权限打开信号量。通过此访问权限，可以调用ReleaseSemaphore（此句柄必须具有 SEMAPHORE_MODIFY_STATE 访问权限），但调用WaitForSingleObject失败，结果为WAIT_FAILED。在此之后致电GetLastError()必须返回ERROR_ACCESS_DENIED。

因此，如果我们想要同时调用ReleaseSemaphore和任何等待函数 - 我们需要对句柄进行 SEMAPHORE_MODIFY_STATE | SYNCHRONIZE 访问。所以需要打开代码

OpenSemaphore(SEMAPHORE_MODIFY_STATE|SYNCHRONIZE, )

当然总是检查api返回值和错误代码可以节省大量时间

Answer 2

如果将timeout设置为0，WaitForSingleObject将始终立即返回，则成功的WaitForSingleObject将返回WAIT_OBJECT_0（恰好具有值0），WFSO与大多数API不同，其中成功由非零返回指示。< / p>

Windows命名信号量未被锁定

2 个答案: