關於協程和libco
本專案Github地址
  協程實現非同步其實就是用同步的業務邏輯程式碼，但內部卻執行非同步等待並進行排程，既保證的程式碼的可讀性，又能實現非同步的高併發。在Windows程式設計中，往往會有大量阻塞的IO操作，比如這段程式碼：

    CHAR buf[4096];
    DWORD Size;
    LONG Offset = 0;
    SIZE_T CSize;

    PVOID CompressData;

    HANDLE g = CreateFile(L"F:\\test.iso", GENERIC_ALL, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL
 
, OPEN_EXISTING, 0, NULL);

    for (int i = 0;i < COUNT;i++) {
        SetFilePointer(g, 4096 * i, &Offset, FILE_BEGIN);
        ReadFile(g, buf, 4096, &Size, NULL);

        COMPRESSOR_HANDLE Com = NULL;
        CompressData = malloc(4096);
        CreateCompressor(COMPRESS_ALGORITHM_LZMS, NULL
 
, &Com);
        if (Com != NULL) {
            Compress(Com, buf, 4096, CompressData, 4096, &CSize);
            CloseCompressor(Com);
        }
        free(CompressData);
    }

    CloseHandle(g);

  這段程式碼中，會從檔案讀取一段固定4096位元組的資料，並將其壓縮。程式在執行時，因為ReadFile是非阻塞IO，壓縮前不得不等待ReadFile完成資料的讀取，而這段時間就會導致CPU資源的浪費，如果能一邊讀取檔案，一邊對已經讀取完的檔案內容進行壓縮，這就會大大提高CPU的利用率。
  後來發明了非同步IO，在Windows上的體現就是IO完成埠，在執行IO操作時，會先像核心註冊一個IO監聽，由核心負責監聽IO的完成並將其掛在IO完成埠的完成佇列裡，這樣應用層可以在這時去做其他的事情，等IO完成了，應用層在輪詢IO完成佇列時就能知曉並執行後序的操作。但這種機制在程式碼上可讀性很差，IO完成的操作和IO發起的操作不在同一個函式中。
  於是現在又重新拾起了協程，在這篇文章中會介紹實現一種非侵入式的協程IO，看看如何在不改變原有同步業務邏輯的情況下實現非同步IO。
  首先需要HOOK掉IO函式為自己自定義的函式，這樣在使用者看來呼叫的仍然是原來的同步IO函式，而我則會在函式內將其修改為非同步IO。
  首先看自定義的函式的第一部分：

/**
 * 自定義的支援協程的ReadFile
 */
BOOL
WINAPI
Coroutine_ReadFile(
    _In_ HANDLE hFile,
    _Out_writes_bytes_to_opt_(nNumberOfBytesToRead, *lpNumberOfBytesRead) __out_data_source(FILE) LPVOID lpBuffer,
    _In_ DWORD nNumberOfBytesToRead,
    _Out_opt_ LPDWORD lpNumberOfBytesRead,
    _Inout_opt_ LPOVERLAPPED lpOverlapped
) {

    //判斷是不是纖程
    if (!IsThreadAFiber()) {
        return System_ReadFile(hFile,
            lpBuffer,
            nNumberOfBytesToRead,
            lpNumberOfBytesRead,
            lpOverlapped
        );
    }

    ...
    //申請一個Overlapped的上下文
    PCOROUTINE_OVERLAPPED_WARPPER OverlappedWarpper = (PCOROUTINE_OVERLAPPED_WARPPER)malloc(sizeof(COROUTINE_OVERLAPPED_WARPPER));
    if (OverlappedWarpper == NULL) {
        *lpNumberOfBytesRead = 0;
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return FALSE;
    }
    memset(OverlappedWarpper, 0, sizeof(COROUTINE_OVERLAPPED_WARPPER));

    ...

    Succeed = System_ReadFile(hFile,
        lpBuffer,
        nNumberOfBytesToRead,
        lpNumberOfBytesRead,
        &OverlappedWarpper->Overlapped
    );
    if (Succeed || GetLastError() != ERROR_IO_PENDING) {
        goto EXIT;
    }

    //手動排程纖程
    CoSyncExecute(FALSE);

    ...

  當用戶呼叫ReadFile時，會跳轉到Coroutine_ReadFile函式中，這個函式保留其他的引數，但額外添加了一個Overlapped引數，這樣這個ReadFile就從同步轉為非同步了。在最後，呼叫了CoSyncExecute來對纖程進行排程。其實這個函式會跳轉到實現排程的纖程中去排程其他處於等待中的纖程。當這個IO完成時，排程演算法會最終排程回該函式的上下文中，纖程就會從CoSyncExecute呼叫後面繼續執行第二部分：

    SetLastError(OverlappedWarpper->ErrorCode);
    if (OverlappedWarpper->ErrorCode != ERROR_SUCCESS) {
        goto EXIT;
    }

    Succeed = TRUE;

EXIT:
    *lpNumberOfBytesRead = OverlappedWarpper->BytesTransfered;
    free(OverlappedWarpper);

    return Succeed;

  在第二部分，獲取並設定了錯誤碼，然後返回完成的IO的位元組數並返回。這樣，在呼叫ReadFile的程式碼邏輯看來，這個ReadFile仍然是阻塞IO，但在阻塞過程中，其實執行流已經跳轉到其他的纖程中繼續執行了，這樣可以充分的利用CPU。
  然後可以看看排程協程是如何進行排程的（當然當前的排程方法並沒有什麼花樣，很簡單）。

/**
 * 排程協程
 */
VOID
WINAPI CoScheduleRoutine(
    LPVOID lpFiberParameter
) {

    ...

    //從TLS中獲取協程例項
    PCOROUTINE_INSTANCE Instance = (PCOROUTINE_INSTANCE)TlsGetValue(0);

    //如果有完成的IO埠事件,優先繼續執行
DEAL_COMPLETED_IO:
    while (GetQueuedCompletionStatus(Instance->Iocp, &ByteTransfered, &IoContext, &Overlapped, Timeout)) {

        PCOROUTINE_OVERLAPPED_WARPPER Context = (PCOROUTINE_OVERLAPPED_WARPPER)
            CONTAINING_RECORD(Overlapped, COROUTINE_OVERLAPPED_WARPPER, Overlapped);
        ...

        //這個結構可能在協程執行中被釋放了
        Victim = Context->Fiber;
        SwitchToFiber(Victim);

        ...

    }

    //繼續執行因為其他原因打斷的協程或者新的協程
    if (!Instance->FiberList->empty()) {

        Victim = (PVOID)Instance->FiberList->front();
        Instance->FiberList->pop_front();
        SwitchToFiber(Victim);

        ...

        //如果有協程可執行，那麼可能後面還有新的協程等待執行
        Timeout = 0;
    }
    else {

        //如果沒有，那麼就讓完成埠等久一點
        Timeout = 500;
    }

    goto DEAL_COMPLETED_IO;
}

  其實很簡單，首先判斷有沒有IO事件已經完成，如果有，直接排程到對應的纖程繼續執行。否則的話，判斷有沒有普通的纖程，如果有，則排程到普通纖程。如果沒有，很可能暫時都沒有任何需要執行的了，就加大等待IO事件完成的超時時間。
  通過這種方式，原來的程式只需要新增初始化和插入業務邏輯的函式，無需改動業務程式碼就可以實現單執行緒的高併發。