TCP文件传输-二级流水线高效模式具体代码实现 future实现双缓冲区切换同步

双缓冲区 二级流水线高效模式，这样可以保证程序在不停的接收和写文件，文件IO操作和网络recv同时进行
本客户端采用了在C++11中引入了async异步调用函数，其封装了异步（多线程）实现的复杂过程。采用futrue 对双缓冲区切换的同步

//---------------------------------------------------------------------------------------------------------------------------------------------------------------------

//  tcp file transport Server code

//---------------------------------------------------------------------------------------------------------------------------------------------------------------------

#include <Winsock2.h>
#include <iostream>
#include <thread>
#include<fstream>
#pragma comment(lib, "Ws2_32.lib")

using namespace std;

/*协议头*/
class FileHeader
{
public:
    void Setname(wchar_t* szfillname)
    {
        wcscpy(_szfillname, szfillname);
    }

    const wchar_t* Getname(void)const
    {
        return _szfillname;
    }

    void Setsize(unsigned long long ullsize)
    {
        _ullfilesize = ullsize;
    }
    unsigned long long Getsize(void)
    {
        return _ullfilesize;
    }

private:
    wchar_t _szfillname[200];//用于装名字
    unsigned long long _ullfilesize;//用于装文件大小的
};

int wmain(int ac,wchar_t* av[])
{
    /* 初始化winsock2库 */
    //Step 0. Initialize winsock2 library...
    WSADATA wsaData;
    wcout << av[1] << endl;
    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
    {
        return 1;
    }

    // Step 1. Ask system for a socket.this socket is waiter
    SOCKET sockServer = ::socket(PF_INET, SOCK_STREAM, 0);

    if (sockServer == INVALID_SOCKET)
    {
        return 1;
    }

    //Step 2. bind the socket to a local address and port.接待套接字
    sockaddr_in addrServer = { 0 };
    addrServer.sin_family = AF_INET;
    addrServer.sin_addr.S_un.S_addr = inet_addr("88.88.106.34");
    //host to network short.小端转大端
    addrServer.sin_port = htons(30001);

    if (::bind(sockServer, reinterpret_cast<const sockaddr*>(&addrServer),
        sizeof addrServer) == SOCKET_ERROR)
    {
        return 1;
    }

    // Step 3. listen. 监听队列的设置  监听五个套接字的连接
    if (listen(sockServer, 5) == SOCKET_ERROR)
    {
        return 1;
    }

    // Step 4. accept.
    sockaddr_in addrClient = { 0 }; //将对放的信息保存在这个结构体里
    int iLength = sizeof addrClient;
    SOCKET sockClient = INVALID_SOCKET;

    while (true)
    {
        //该返回的套接字才是用于收发的套接字-这里的逻辑是 一个连接开一个线程
        sockClient = ::accept(sockServer, reinterpret_cast<sockaddr*>(&addrClient), &iLength);
        if (sockClient == INVALID_SOCKET)
        {
            return 1;
        }
        
        thread t1([sockClient,av]()->void {

            //open  a file and retrieve the information.
            fstream fs;
            fs.open(av[1], fstream::in|fstream::binary);
            if (!fs)
            {
                return;
            }
            wcout << av[1] << endl;
            unsigned long long ullSize = 0ull;
            fs.seekg(0, fstream::end); //文件指针移到末尾
            ullSize = fs.tellg();      //获取文件的大小
            fs.seekg(0, fstream::beg); //再将文件指针移到起始位置
    
            //send file header 先发送文件头
            FileHeader header;
            header.Setsize(ullSize);
            header.Setname(av[1]);
            unsigned long long iResult = ::send(sockClient, reinterpret_cast<const char*>(&header), sizeof(header), 0);
            if (iResult<=0)
            {
                return;
            }

            //send body of file 发送文件本生 多次发送
            char  readingBuf[4096];
            while(!fs.eof())
            {
                fs.read(readingBuf, 4096);              //读进buf
                iResult = fs.gcount() ;                  //这里需要注意的是tellg()函数是累计的 上次实际读了多少应该用gcount()函数
                ::send(sockClient, reinterpret_cast<const char*>(readingBuf), iResult, 0);
                //cout << "shijisend:" << shijie<<"tellg:" << iResult<<"last"<< lastReadSize <<endl;
            }
            fs.close();    
            closesocket(sockClient);
        });

        t1.detach();
    }

    closesocket(sockServer);
    WSACleanup();
    return 0;
}

 

//---------------------------------------------------------------------------------------------------------------------------------------------------------------------

//  tcp file transport Client code

//---------------------------------------------------------------------------------------------------------------------------------------------------------------------

#include <Winsock2.h>
// Need to link with Ws2_32.lib
#pragma comment(lib, "Ws2_32.lib")
#include <iostream>
#include "future"

#include <fstream>
#include "thread"
#include<future>

#define  BUFFSIZE 1024*1024*50
using namespace std;

class Header
{
public:
    void Setname(wchar_t* szfillname)
    {
        wcscpy(_szfillname, szfillname);
    }

    const wchar_t* Getname(void)const
    {
        return _szfillname;
    }

    void Setsize(unsigned long long ullsize)
    {
        _ullfilesize = ullsize;
    }
    unsigned long long Getsize(void)
    {
        return _ullfilesize;
    }

private:
    wchar_t _szfillname[200];//用于装名字
    unsigned long long _ullfilesize;//用于装文件大小的
};

int wmain(int ac, wchar_t* av[])
{
    /* 初始化winsock2库 */
    // Step 0. Initialize winsock2 library...
    WSADATA wsaData;

    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
    {
        return 1;
    }

    //1.创建套接字
    SOCKET socksever = ::socket(PF_INET, SOCK_STREAM, 0);
    if (socksever == INVALID_SOCKET)
    {
        return 1;
    }
    //2.connect
    sockaddr_in addrsocksever = { 0 };
    addrsocksever.sin_family = AF_INET;
    addrsocksever.sin_addr.S_un.S_addr = inet_addr("192.168.0.44");
    addrsocksever.sin_port = htons(30001);

    if (::connect(socksever, reinterpret_cast<const sockaddr*>
        (&addrsocksever), sizeof addrsocksever) == SOCKET_ERROR)
    {
        return 1;
    }
    //3.receive header of file 
    Header fileheader;
    int ineedtorecieve = sizeof fileheader;
    int irecv = 0; //实际接多少
    int itotalrecv = 0;
    do
    {
        irecv = ::recv(socksever, reinterpret_cast<char*>(&fileheader) + itotalrecv, ineedtorecieve, 0);
        itotalrecv += irecv;
    } while ((ineedtorecieve -= irecv) > 0);

    //4. open a file and write to..
    fstream fs;
    fs.open(av[1], iostream::out | iostream::binary | iostream::trunc);
    if (!fs)
    {
        return 1;
    }

    //5.  recieve body of file ..

    char*bufa = new char[BUFFSIZE];
    char*bufb = new char[BUFFSIZE];
    char* nextbuf = bufa;  //指针刚开始执行bufa

    future<int>fut;

    static bool bwait = false;

    unsigned long long ullremindersize = fileheader.Getsize();

    while (ullremindersize > 0)
    {
        itotalrecv = 0;//这个地方很重要，每缓冲区塞满了后，这个必须清零

        ineedtorecieve = BUFFSIZE > ullremindersize ? ullremindersize : BUFFSIZE;

        while (ineedtorecieve > 0)
        {

            irecv = ::recv(socksever, nextbuf + itotalrecv, ineedtorecieve, 0);
            ullremindersize -= irecv;
            itotalrecv += irecv;
            ineedtorecieve -= irecv;
        }
        /*同步，fut.get()会一直阻塞，除非async执行结束*/
        if (bwait)
        {
            fut.get();
        }

        //开线程进行文件IO操作
        fut = ::async([&fs, nextbuf, itotalrecv](void)->int
        {
            fs.write(nextbuf,itotalrecv);
            return 1;
        });

        //刚开始假设上面的文件写入操作还没执行完毕，主线线程已经跑到下面且继续执行，最后会卡在fut.get函数 直到线程结束
        //线程结束，刚好缓冲区已经切换完毕，又开一个线程执行文件写入操作。
        nextbuf = nextbuf == bufa ? bufb : bufa;
        bwait = true;

    }

    closesocket(socksever);

    if (bwait)//循环退出，子线程还在文件IO操作
    {
        fut.get();
    }

    fs.close();

    if (bufa)
    {
        delete[]bufa;
        bufa = nullptr;
    }

    if (bufb)
    {
        delete[]bufb;
        bufb = nullptr;
    }
    return 0;

}