您的位置：首页 > 移动开发

重叠IO overlapped I/O 运用详解

2015-10-29 12:29 369 查看

I/O设备处理必然让主程序停下来干等I/O的完成,

对这个问题有
方法一：使用另一个线程进行I/O。这个方案可行，但是麻烦。                即 CreateThread(…………)；创建一个子线程做其他事情。      Readfile(^…………)；阻塞方式读数据。
方法二：使用overlapped I/O。
overlapped I/O是WIN32的一项技术，你可以要求操作系统为你传送数据，并且在传送完毕时通知你。这项技术使你的程序在I/O进行过程中仍然能够继续处理事务。事实上，操作系统内部正是以线程来I/O完成overlapped
I/O。你可以获得线程的所有利益，而不需付出什么痛苦的代价

怎样使用overlapped I/O：
进行I/O操作时，指定overlapped方式
使用CreateFile ()，将其第6个参数指定为FILE_FLAG_OVERLAPPED，
就是准备使用overlapped的方式构造或打开文件;

如果采用 overlapped，那么ReadFile()、WriteFile()的第5个参数必须提供一个指针，
指向一个OVERLAPPED结构。 OVERLAPPED用于记录了当前正在操作的文件一些相关信息。
//功能：从指定文件的1500位置读入300个字节
int main()

{

    BOOL rc;

    HANDLE hFile;

    DWORD numread;

    OVERLAPPED overlap;

    char buf[512];

    char szPath=”c:\\xxxx\xxxx”;

    hFile = CreateFile( szPath,

                    GENERIC_READ,

                    FILE_SHARE_READ|FILE_SHARE_WRITE,

                    NULL,

                    OPEN_EXISTING,

                    FILE_FLAG_OVERLAPPED, // 以overlapped打开文件
                    NULL

                );
// OVERLAPPED结构实始化为0

    memset(&overlap, 0, sizeof(overlap));

    //指定文件位置是1500;

    overlap.Offset = 1500;



    rc = ReadFile(hFile,buf,300,&numread,&overlap);

    //因为是overlapped操作，ReadFile会将读文件请求放入读队列之后立即返回（false）,而不会等到文件读完才返回(true)

    if (rc)

    {
…………此处即得到数据了。
       //文件真是被读完了，rc为true

       // 或当数据被放入cache中，或操作系统认为它可以很快速地取得数据，rc为true

    }

    else

    {

        if (GetLastError() == ERROR_IO_PENDING)

        {//当错误是ERROR_IO_PENDING,那意味着读文件的操作还在进行中
         //等候，直到文件读完
            WaitForSingleObject(hFile, INFINITE);

            rc = GetOverlappedResult(hFile,&overlap,&numread,FALSE);

            //上面二条语句完成的功能与下面一条语句的功能等价：
一只阻塞等到得到数据才继续下面。
            // GetOverlappedResult(hFile,&overlap,&numread,TRUE);

         }

         else

         {

            //出错了
        }

    }

    CloseHandle(hFile);

    return EXIT_SUCCESS;

}
在实际工作中，若有几个操作同一个文件时,

怎么办？我们可以利用OVERLAPPED结构中提供的event来解决上面遇到的问题。
注意，你所使用的event对象必须是一个MANUAL型的；否则，可能产生竞争条件。
int main()

{

    int i;

    BOOL rc;

    char szPath=”x:\\xxxx\xxxx”;

    // 以overlapped的方式打开文件
    ghFile = CreateFile( szPath,

                    GENERIC_READ,

                    FILE_SHARE_READ|FILE_SHARE_WRITE,

                    NULL,

                    OPEN_EXISTING,

                    FILE_FLAG_OVERLAPPED,

                    NULL

                );

    for (i=0; i<MAX_REQUESTS; i++)   requests 同时有N个同时读取文件
    {

        //将同一文件按几个部分按overlapped方式同时读
        //注意看QueueRequest函数是如何运做的,每次读16384个块
        QueueRequest(i, i*16384, READ_SIZE);

    }

    // 等候所有操作结束;

    //隐含条件：当一个操作完成时，其对应的event对象会被激活
    WaitForMultipleObjects(MAX_REQUESTS, ghEvents, TRUE, INFINITE);

    // 收尾操作
    for (i=0; i<MAX_REQUESTS; i++)

    {

        DWORD dwNumread;

        rc = GetOverlappedResult(

                                ghFile,

                                &gOverlapped[i],

                                &dwNumread,

                                FALSE

                            );

        CloseHandle(gOverlapped[i].hEvent);

    }

    CloseHandle(ghFile);

    return EXIT_SUCCESS;

}

//当读操作完成以后，gOverlapped[nIndex].hEvent会系统被激发
int QueueRequest(int nIndex, DWORD dwLocation, DWORD dwAmount)

{

    //构造一个MANUAL型的event对象
    ghEvents[nIndex] = CreateEvent(NULL, TRUE, FALSE, NULL)；
    //将此event对象置入OVERLAPPED结构
    gOverlapped[nIndex].hEvent = ghEvents[nIndex];
每个重叠对象对应一个事件。
    gOverlapped[nIndex].Offset = dwLocation;

    for (i=0; i<MAX_TRY_COUNT; i++) //尝试几次。
   {

      //文件ghFile唯一
       rc = ReadFile(ghFile, gBuffers[nIndex],&dwNumread,&gOverlapped[nIndex]);

       if (rc) 如果立刻读到数据则返回真
         return TRUE;

       err = GetLastError();

       if (err == ERROR_IO_PENDING)

       {

           //当错误是ERROR_IO_PENDING,那意味着读文件的操作还在进行中
          return TRUE;

       }

       // 处理一些可恢复的错误
       if ( err == ERROR_INVALID_USER_BUFFER ||

            err == ERROR_NOT_ENOUGH_QUOTA ||

            err == ERROR_NOT_ENOUGH_MEMORY )

        {

           sleep(50);

           continue;//重试
        }

        // 如果GetLastError()返回的不是以上列出的错误，放弃
        break;

    }
    return -1;
}
程序流程：
1： N个用户同时读取一个文件的各个部分，且每个用户对应一个重叠对象和事件。
2：调用WaitForMultipleObjects(MAX_REQUESTS, ghEvents, TRUE, INFINITE) 当任何一个用户的读操作完成时，函数停止阻塞。并且ghEvents中对应于的读取数据完毕的用户的事件被激活。
3：调用GetOverlappedResult 取得读取数据完毕的用户编号。

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签： io 重叠

相关文章推荐

新的分享

章节导航