如何在c++中异步读/写

How to asynchronously read/write in C++?

本文关键字：异步 c++      更新时间：2023-10-16

如何在c++中使用专用读/写线程将一个流复制到另一个流?

假设我有这些方法(不是真实的，但为了说明这一点)来读取/写入数据。这些读/写函数可以表示任何东西(网络/文件/USB/串行/等)。

// returns the number of bytes read
void read(char* buffer, int bufferSize, int* bytesRead);
// returns the number of bytes written
void write(char* buffer, int bufferSize, int* bytesWritten);

解决方案也应该是可移植的。

注:我知道Windows有一个FILE_FLAG_OVERLAPPED特性，但这假设读/写是文件IO。记住，这些读/写方法可以表示任何东西。

这是我想到的解决方案。

<标题>头h1> CPP h1> 
#include <stdio.h>
#include <tchar.h>
#include "AsyncReadWrite.h"
struct ReadTestStream : ReadStream
{
    int readCount = 0;
    int read(char* buffer, int bufferSize, int* bytesRead)
    {
        printf("Starting read...n");
        memset(buffer, bufferSize, 0);
        if (readCount == 10)
        {
            *bytesRead = 0;
            return 0;
        }
        // pretend this function takes a while!
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
        char buff[100];
        sprintf_s(buff, "This is read number %dn", readCount);
        strcpy_s(buffer, sizeof(buff), buff);
        *bytesRead = strlen(buffer);
        readCount++;
        printf("Finished read...n");
        return 0;
    }
};
struct WriteTestStream : WriteStream
{
    int write(char* buffer, int bufferSize, int* bytesWritten)
    {
        printf("Starting write...n");
        // pretend this function takes a while!
        std::this_thread::sleep_for(std::chrono::milliseconds(500));
        printf(buffer);
        printf("Finished write...n");
        return 0;
    }
};
int _tmain(int argc, _TCHAR* argv[])
{
    BufferBlockManager bufferBlockManager(5, 4096);
    ReadTestStream readStream;
    WriteTestStream writeStream;
    int readResult = 0;
    int writeResult = 0;
    printf("Starting copy...n");
    AsyncCopyStream(&bufferBlockManager, &readStream, &writeStream, &readResult, &writeResult);
    printf("Finished copy... readResult=%d writeResult=%d n", readResult, writeResult);
    getchar();
    return 0;
}

EDIT:我把我的解决方案放入GitHub存储库中。如果您希望使用此代码，请参考存储库，因为它可能比此答案更新得更多。

通常情况下，在读取和写入之间交替的每个方向上只有一个线程

相关文章：