如何正確等待 C++ 中的條件變量？

Question

嘗試在 Linux 下的 C++ 中創建異步 I/O 文件讀取器。 我的例子有兩個緩沖區。 第一個讀取塊。 然后，每次圍繞主循環，我異步啟動 IO 並調用運行當前塊的模擬處理的process() 。 處理完成后，我們等待條件變量。 這個想法是異步處理程序應該通知條件變量。

不幸的是， notify似乎發生在wait之前，這似乎不是條件變量wait() function 的工作方式。 我應該如何重寫代碼以便循環等待異步 io 完成？

#include <aio.h>
#include <fcntl.h>
#include <signal.h>
#include <unistd.h>

#include <condition_variable>
#include <cstring>
#include <iostream>
#include <thread>

using namespace std;
using namespace std::chrono_literals;

constexpr uint32_t blockSize = 512;

mutex readMutex;

condition_variable cv;

int fh;
int bytesRead;

void process(char* buf, uint32_t bytesRead) {
  cout << "processing..." << endl;
  usleep(100000);
}

void aio_completion_handler(sigval_t sigval) {
  struct aiocb* req = (struct aiocb*)sigval.sival_ptr;

  // check whether asynch operation is complete
  if (aio_error(req) == 0) {
    int ret = aio_return(req);
        bytesRead = req->aio_nbytes;
    cout << "ret == " << ret << endl;
    cout << (char*)req->aio_buf << endl;
  }
    {
        unique_lock<mutex> readLock(readMutex);
        cv.notify_one();
    }
}

void thready() {
  char* buf1 = new char[blockSize];
  char* buf2 = new char[blockSize];
  aiocb cb;
  char* processbuf = buf1;
  char* readbuf = buf2;
  fh = open("smallfile.dat", O_RDONLY);
  if (fh < 0) {
    throw std::runtime_error("cannot open file!");
  }

  memset(&cb, 0, sizeof(aiocb));
  cb.aio_fildes = fh;
  cb.aio_nbytes = blockSize;
  cb.aio_offset = 0;

  // Fill in callback information
  /*
  Using SIGEV_THREAD to request a thread callback function as a notification
  method
  */
  cb.aio_sigevent.sigev_notify_attributes = nullptr;
  cb.aio_sigevent.sigev_notify = SIGEV_THREAD;
  cb.aio_sigevent.sigev_notify_function = aio_completion_handler;
  /*
  The context to be transmitted is loaded into the handler (in this case, a
  reference to the aiocb request itself). In this handler, we simply refer to
  the arrived sigval pointer and use the AIO function to verify that the request
  has been completed.
  */
  cb.aio_sigevent.sigev_value.sival_ptr = &cb;

  int currentBytesRead = read(fh, buf1, blockSize);  // read the 1st block

  while (true) {
    cb.aio_buf = readbuf;
    aio_read(&cb);  // each next block is read asynchronously
    process(processbuf, currentBytesRead);  // process while waiting
        {
            unique_lock<mutex> readLock(readMutex);
            cv.wait(readLock);
        }
        currentBytesRead = bytesRead; // make local copy of global modified by the asynch code
    if (currentBytesRead < blockSize) {
      break;  // last time, get out
    }
    cout << "back from wait" << endl;
    swap(processbuf, readbuf);     // switch to other buffer for next time
    currentBytesRead = bytesRead;  // create local copy
  }

  delete[] buf1;
  delete[] buf2;
}

int main() {
  try {
    thready();
  } catch (std::exception& e) {
    cerr << e.what() << '\n';
  }
  return 0;
}

Answer 1

條件變量通常應用於

• 等到謂詞（例如共享變量）可能發生變化，並且
• 通知等待線程謂詞可能已更改，以便等待線程再次檢查謂詞。

但是，您似乎正在嘗試使用條件變量本身的 state 作為謂詞。 這不是應該使用條件變量的方式，並且可能會導致諸如您的問題中描述的競爭條件。 始終檢查謂詞的另一個原因是條件變量可能會出現虛假喚醒。

在您的情況下，創建共享變量可能是合適的

bool operation_completed = false;

並將該變量用作條件變量的謂詞。 對該變量的訪問應始終由互斥鎖控制。

然后你可以改變線條

{
    unique_lock<mutex> readLock(readMutex);
    cv.notify_one();
}

至

{
    unique_lock<mutex> readLock(readMutex);
    operation_completed = true;
    cv.notify_one();
}

並更改線條

{
    unique_lock<mutex> readLock(readMutex);
    cv.wait(readLock);
}

至：

{
    unique_lock<mutex> readLock(readMutex);
    while ( !operation_completed )
        cv.wait(readLock);
}

當然，在互斥鎖被鎖定的情況下， operation_completed也應該在適當的時候設置回false 。