我用wininet处理http请求

我想应该分为两个方面吧，一个是服务器的网络响应和处理，一个是接收到数据以后的分析展现。
1 网络响应处理
  如果是tomcat或者iis这类的应用服务器，这些已经比较成熟了，要提高处理能力和响应速度的话用多机做负载并发比较好。但是相对来说资源开销大一点。
   另一个是自己写server服务器，这个主要的瓶颈在于网络模型，一般用iocp模型效率会高一点，普通的服务器并发量应该是可以达到2000-3000左右。而且可以自己把数据包进行压缩传输，这个对网络处理的压力就相对小一点。
2 客户端的分析响应
  如果是由comcat或者是iis发回来的http数据包，如果过大可能分批接收的话，对网络的依赖就比较高，相当于界面有个等待的过程，造成界面缓慢，这个如果是自己写的server就可以压缩，一般对于xml或者json的文本压缩率可以达到90%以上。
  另外对大容量或者大节点的json或者xml的解析因为涉及到遍历节点速度也会慢一点。这个没有什么好的方法，优化算法，或者是升级cpu可能会好一点。

我想两个方面处理吧，一个是提高服务器的网络处理性能，压缩数据包大小，前段使用多线程解析后界面显示，这样应该能大幅度提高性能。

引用 2 楼 zdrone 的回复:

我想应该分为两个方面吧，一个是服务器的网络响应和处理，一个是接收到数据以后的分析展现。
1 网络响应处理
  如果是tomcat或者iis这类的应用服务器，这些已经比较成熟了，要提高处理能力和响应速度的话用多机做负载并发比较好。但是相对来说资源开销大一点。
   另一个是自己写server服务器，这个主要的瓶颈在于网络模型，一般用iocp模型效率会高一点，普通的服务器并发量应该是可以达到2000-3000左右。而且可以自己把数据包进行压缩传输，这个对网络处理的压力就相对小一点。
2 客户端的分析响应
  如果是由comcat或者是iis发回来的http数据包，如果过大可能分批接收的话，对网络的依赖就比较高，相当于界面有个等待的过程，造成界面缓慢，这个如果是自己写的server就可以压缩，一般对于xml或者json的文本压缩率可以达到90%以上。
  另外对大容量或者大节点的json或者xml的解析因为涉及到遍历节点速度也会慢一点。这个没有什么好的方法，优化算法，或者是升级cpu可能会好一点。

我想两个方面处理吧，一个是提高服务器的网络处理性能，压缩数据包大小，前段使用多线程解析后界面显示，这样应该能大幅度提高性能。

服务器不是我做的，没办法。具体帮我讲讲客户端怎么请求，怎么多线程解析后界面显示策略吧，谢谢了

这是mfc做的客户端程序

不知道你想怎么弄  我们是发送请求的时候可以直接响应界面事件 组包 发送请求
处理返回的数据时单独开启线程来处理 处理结束后可以消息映射给界面线程 通知界面跟新
我用UDP 不卡

发送协议的时候要自己开个线程去发送

如果把发送写在界面消息响应函数里面就是楼主这种情况了。

引用 5 楼 modyaj 的回复:

不知道你想怎么弄  我们是发送请求的时候可以直接响应界面事件 组包 发送请求
处理返回的数据时单独开启线程来处理 处理结束后可以消息映射给界面线程 通知界面跟新
我用UDP 不卡

是针对每个返回各开一个线程，还是开一个线程处理所用返回。设计思路麻烦说详细点，谢谢

引用 6 楼 tiger9991 的回复:

发送协议的时候要自己开个线程去发送

如果把发送写在界面消息响应函数里面就是楼主这种情况了。

终于有大神来看我了麻烦您稍微在具体点吧，谢谢啊

请求数据和显示应该放入不同的线程中，请求数据可能会进行网络等待，因此造成了阻塞

另外，也可以使用Inet的异步通知，不要使用同步读取，估计也能解决你的问题

把什么网络访问部分的操作放到单独的工作线程中去做，UI线程只负责显示

引用 9 楼 worldy 的回复:

请求数据和显示应该放入不同的线程中，请求数据可能会进行网络等待，因此造成了阻塞

引用 11 楼 VisualEleven 的回复:

把什么网络访问部分的操作放到单独的工作线程中去做，UI线程只负责显示

这个道理我也知道，就是不知道具体怎么写好，我感觉我写的很垃圾。比如现在某窗口有个发送按钮，我点之后就开一个线程吗？到处都是这样的请求，这样不是要开好多线程？怎么写才好啊

引用 3 楼 FRcheng 的回复:

Quote: 引用 2 楼 zdrone 的回复:

我想应该分为两个方面吧，一个是服务器的网络响应和处理，一个是接收到数据以后的分析展现。
1 网络响应处理
  如果是tomcat或者iis这类的应用服务器，这些已经比较成熟了，要提高处理能力和响应速度的话用多机做负载并发比较好。但是相对来说资源开销大一点。
   另一个是自己写server服务器，这个主要的瓶颈在于网络模型，一般用iocp模型效率会高一点，普通的服务器并发量应该是可以达到2000-3000左右。而且可以自己把数据包进行压缩传输，这个对网络处理的压力就相对小一点。
2 客户端的分析响应
  如果是由comcat或者是iis发回来的http数据包，如果过大可能分批接收的话，对网络的依赖就比较高，相当于界面有个等待的过程，造成界面缓慢，这个如果是自己写的server就可以压缩，一般对于xml或者json的文本压缩率可以达到90%以上。
  另外对大容量或者大节点的json或者xml的解析因为涉及到遍历节点速度也会慢一点。这个没有什么好的方法，优化算法，或者是升级cpu可能会好一点。

我想两个方面处理吧，一个是提高服务器的网络处理性能，压缩数据包大小，前段使用多线程解析后界面显示，这样应该能大幅度提高性能。

服务器不是我做的，没办法。具体帮我讲讲客户端怎么请求，怎么多线程解析后界面显示策略吧，谢谢了

mark

引用 12 楼 FRcheng 的回复:

Quote: 引用 9 楼 worldy 的回复:

请求数据和显示应该放入不同的线程中，请求数据可能会进行网络等待，因此造成了阻塞

引用 11 楼 VisualEleven 的回复:

把什么网络访问部分的操作放到单独的工作线程中去做，UI线程只负责显示

这个道理我也知道，就是不知道具体怎么写好，我感觉我写的很垃圾。比如现在某窗口有个发送按钮，我点之后就开一个线程吗？到处都是这样的请求，这样不是要开好多线程？怎么写才好啊

INet之

同步和异步传输
OpenURL 方法以同步方式传输数据。在这里，同步指的是传输操作未完成之前，不能执行其它过程。这样数据传输就必须在执行其它代码之前完成。

而 Execute 方法以异步方式传输数据。在调用 Execute 方法时，传输操作与其它过程无关。这样，在调用 Execute 方法后，在后台接收数据的同时，即可同时执行其它代码。

对 Internet Transfer 控件的使用者来说这意味着什么？简单地说，用 OpenURL 方法能够直接得到可保存到磁盘的数据流（如上所述），或者直接在 TextBox 控件中阅览（如果数据是文本格式的）。从另一方面说，如果用 Execute 方法获取数据，则必须用 StateChanged 事件监视该控件的连接状态。当达到适当的状态时，调用 GetChunk 方法从控件的缓冲区获取数据。下面更详细地讨论这一操作。

在 HTTP 协议上使用 Execute 方法
HTTP 协议允许客户机用 GET、HEAD、POST 和 PUT 命令向服务器请求数据。下表中列出了这些操作：

操作 描述 示例 
GET 获取 url 中命名的文件。 Execute "http://www.microsoft.com" & _
"/default.htm", "GET"

 
HEAD 只获取 URL 属性中命名的文件的文件标头。 Execute , "HEAD"
 
POST 提供附加数据，以支持向远程主机的请求。 Execute , "POST", strFormData
 
PUT 替换指定的 URL 中的数据。 

引用 7 楼 FRcheng 的回复:

Quote: 引用 5 楼 modyaj 的回复:

不知道你想怎么弄  我们是发送请求的时候可以直接响应界面事件 组包 发送请求
处理返回的数据时单独开启线程来处理 处理结束后可以消息映射给界面线程 通知界面跟新
我用UDP 不卡

是针对每个返回各开一个线程，还是开一个线程处理所用返回。设计思路麻烦说详细点，谢谢

一个线程专门处理录音，也就是处理所有的返回，不用每次语音都开一个线程

降低虚高的界面刷新频率。

界面只显示数据，复杂的处理放在后台线程里执行，执行完post到界面去显示

界面里如果超过100毫秒不响应是会感觉到卡顿的

这个问题我遇到过，我是用线程解决的。你可以用线程去试一试

引用 17 楼 zhao4zhong1 的回复:

降低虚高的界面刷新频率。

引用 18 楼 hurryboylqs 的回复:

界面只显示数据，复杂的处理放在后台线程里执行，执行完post到界面去显示

我有10来个协议封装好了的，不同窗口会用到不同协议。我最想知道，用线程怎么做

将一切“异步＋队列＋池”化。

引用 22 楼 zhao4zhong1 的回复:

将一切“异步＋队列＋池”化。

哈哈~知道最终就是这么个说法，有例子参考吗？

网络请求，队列，线程，怎么用啊

利用多线程就行，让界面和工作线程分开。

引用 25 楼 chelp 的回复:

利用多线程就行，让界面和工作线程分开。

这个我知道，关键是方法呀，大家都不说重点

界面线程：接受自定义消息后，刷新屏幕
工作线程：可以用采用线程池或者异步模式通信，一个线程接受多个Socket字
推荐 Window32多线程

引用 27 楼 chelp 的回复:

界面线程：接受自定义消息后，刷新屏幕
工作线程：可以用采用线程池或者异步模式通信，一个线程接受多个Socket字
推荐 Window32多线程

引用 28 楼 FRcheng 的回复:

Quote: 引用 27 楼 chelp 的回复:

界面线程：接受自定义消息后，刷新屏幕
工作线程：可以用采用线程池或者异步模式通信，一个线程接受多个Socket字
推荐 Window32多线程

用最最傻，没有任何的技巧啥的，就是不可靠的方法来说，比如说你按一下按钮，你开一个线程做一件你知道会卡的事情。当然得像赵老师说的一样，要将一切“异步＋队列＋池”化。 这才是好方法

你最好还是把一切东西集中到一切来做。如果按我上面说的那个不可靠的方法做，你以后改什么玩意，你会哭的很销魂

引用 22 楼 zhao4zhong1 的回复:

将一切“异步＋队列＋池”化。

大神，我在一个线程里面创建一个HWND_MESSAGE窗口，所有网络请求PostMessage给这个线程处理，处理完了这个线程又PostMessage通知主线程取数据显示，这样怎么样？感觉这就是一个ui线程，单它不show窗口。能够达到我的要求。除此之外还有什么良策吗？

别说了，多线陈。

引用 31 楼 FRcheng 的回复:

Quote: 引用 22 楼 zhao4zhong1 的回复:

将一切“异步＋队列＋池”化。

大神，我在一个线程里面创建一个HWND_MESSAGE窗口，所有网络请求PostMessage给这个线程处理，处理完了这个线程又PostMessage通知主线程取数据显示，这样怎么样？感觉这就是一个ui线程，单它不show窗口。能够达到我的要求。除此之外还有什么良策吗？

仅供参考：

//循环向a函数每次发送200个字节长度（这个是固定的）的buffer,

//a函数中需要将循环传进来的buffer，组成240字节（也是固定的）的新buffer进行处理，

//在处理的时候每次从新buffer中取两个字节打印

#ifdef WIN32

    #pragma warning(disable:4996)

#endif

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#ifdef WIN32

    #include <windows.h>

    #include <process.h>

    #include <io.h>

    #define  MYVOID             void

    #define  vsnprintf          _vsnprintf

#else

    #include <unistd.h>

    #include <sys/time.h>

    #include <pthread.h>

    #define  CRITICAL_SECTION   pthread_mutex_t

    #define  MYVOID             void *

#endif

//Log{

#define MAXLOGSIZE 20000000

#define MAXLINSIZE 16000

#include <time.h>

#include <sys/timeb.h>

#include <stdarg.h>

char logfilename1[]="MyLog1.log";

char logfilename2[]="MyLog2.log";

static char logstr[MAXLINSIZE+1];

char datestr[16];

char timestr[16];

char mss[4];

CRITICAL_SECTION cs_log;

FILE *flog;

#ifdef WIN32

void Lock(CRITICAL_SECTION *l) {

    EnterCriticalSection(l);

}

void Unlock(CRITICAL_SECTION *l) {

    LeaveCriticalSection(l);

}

void sleep_ms(int ms) {

    Sleep(ms);

}

#else

void Lock(CRITICAL_SECTION *l) {

    pthread_mutex_lock(l);

}

void Unlock(CRITICAL_SECTION *l) {

    pthread_mutex_unlock(l);

}

void sleep_ms(int ms) {

    usleep(ms*1000);

}

#endif

void LogV(const char *pszFmt,va_list argp) {

    struct tm *now;

    struct timeb tb;



    if (NULL==pszFmt||0==pszFmt[0]) return;

    vsnprintf(logstr,MAXLINSIZE,pszFmt,argp);

    ftime(&tb);

    now=localtime(&tb.time);

    sprintf(datestr,"%04d-%02d-%02d",now->tm_year+1900,now->tm_mon+1,now->tm_mday);

    sprintf(timestr,"%02d:%02d:%02d",now->tm_hour     ,now->tm_min  ,now->tm_sec );

    sprintf(mss,"%03d",tb.millitm);

    printf("%s %s.%s %s",datestr,timestr,mss,logstr);

    flog=fopen(logfilename1,"a");

    if (NULL!=flog) {

        fprintf(flog,"%s %s.%s %s",datestr,timestr,mss,logstr);

        if (ftell(flog)>MAXLOGSIZE) {

            fclose(flog);

            if (rename(logfilename1,logfilename2)) {

                remove(logfilename2);

                rename(logfilename1,logfilename2);

            }

        } else {

            fclose(flog);

        }

    }

}

void Log(const char *pszFmt,...) {

    va_list argp;



    Lock(&cs_log);

    va_start(argp,pszFmt);

    LogV(pszFmt,argp);

    va_end(argp);

    Unlock(&cs_log);

}

//Log}

#define ASIZE    200

#define BSIZE    240

#define CSIZE      2

char Abuf[ASIZE];

char Cbuf[CSIZE];

CRITICAL_SECTION cs_HEX ;

CRITICAL_SECTION cs_BBB ;

struct FIFO_BUFFER {

    int  head;

    int  tail;

    int  size;

    char data[BSIZE];

} BBB;

int No_Loop=0;

void HexDump(int cn,char *buf,int len) {

    int i,j,k;

    char binstr[80];



    Lock(&cs_HEX);

    for (i=0;i<len;i++) {

        if (0==(i%16)) {

            sprintf(binstr,"%03d %04x -",cn,i);

            sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);

        } else if (15==(i%16)) {

            sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);

            sprintf(binstr,"%s  ",binstr);

            for (j=i-15;j<=i;j++) {

                sprintf(binstr,"%s%c",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');

            }

            Log("%s\n",binstr);

        } else {

            sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);

        }

    }

    if (0!=(i%16)) {

        k=16-(i%16);

        for (j=0;j<k;j++) {

            sprintf(binstr,"%s   ",binstr);

        }

        sprintf(binstr,"%s  ",binstr);

        k=16-k;

        for (j=i-k;j<i;j++) {

            sprintf(binstr,"%s%c",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');

        }

        Log("%s\n",binstr);

    }

    Unlock(&cs_HEX);

}

int GetFromRBuf(int cn,CRITICAL_SECTION *cs,FIFO_BUFFER *fbuf,char *buf,int len) {

    int lent,len1,len2;



    lent=0;

    Lock(cs);

    if (fbuf->size>=len) {

        lent=len;

        if (fbuf->head+lent>BSIZE) {

            len1=BSIZE-fbuf->head;

            memcpy(buf     ,fbuf->data+fbuf->head,len1);

            len2=lent-len1;

            memcpy(buf+len1,fbuf->data           ,len2);

            fbuf->head=len2;

        } else {

            memcpy(buf     ,fbuf->data+fbuf->head,lent);

            fbuf->head+=lent;

        }

        fbuf->size-=lent;

    }

    Unlock(cs);

    return lent;

}

MYVOID thdB(void *pcn) {

    char        *recv_buf;

    int          recv_nbytes;

    int          cn;

    int          wc;

    int          pb;



    cn=(int)pcn;

    Log("%03d thdB              thread begin...\n",cn);

    while (1) {

        sleep_ms(10);

        recv_buf=(char *)Cbuf;

        recv_nbytes=CSIZE;

        wc=0;

        while (1) {

            pb=GetFromRBuf(cn,&cs_BBB,&BBB,recv_buf,recv_nbytes);

            if (pb) {

                Log("%03d recv %d bytes\n",cn,pb);

                HexDump(cn,recv_buf,pb);

                sleep_ms(1);

            } else {

                sleep_ms(1000);

            }

            if (No_Loop) break;//

            wc++;

            if (wc>3600) Log("%03d %d==wc>3600!\n",cn,wc);

        }

        if (No_Loop) break;//

    }

#ifndef WIN32

    pthread_exit(NULL);

#endif

}

int PutToRBuf(int cn,CRITICAL_SECTION *cs,FIFO_BUFFER *fbuf,char *buf,int len) {

    int lent,len1,len2;



    Lock(cs);

    lent=len;

    if (fbuf->size+lent>BSIZE) {

        lent=BSIZE-fbuf->size;

    }

    if (fbuf->tail+lent>BSIZE) {

        len1=BSIZE-fbuf->tail;

        memcpy(fbuf->data+fbuf->tail,buf     ,len1);

        len2=lent-len1;

        memcpy(fbuf->data           ,buf+len1,len2);

        fbuf->tail=len2;

    } else {

        memcpy(fbuf->data+fbuf->tail,buf     ,lent);

        fbuf->tail+=lent;

    }

    fbuf->size+=lent;

    Unlock(cs);

    return lent;

}

MYVOID thdA(void *pcn) {

    char        *send_buf;

    int          send_nbytes;

    int          cn;

    int          wc;

    int           a;

    int          pa;



    cn=(int)pcn;

    Log("%03d thdA              thread begin...\n",cn);

    a=0;

    while (1) {

        sleep_ms(100);

        memset(Abuf,a,ASIZE);

        a=(a+1)%256;

        if (16==a) {No_Loop=1;break;}//去掉这句可以让程序一直循环直到按Ctrl+C或Ctrl+Break或当前目录下存在文件No_Loop

        send_buf=(char *)Abuf;

        send_nbytes=ASIZE;

        Log("%03d sending %d bytes\n",cn,send_nbytes);

        HexDump(cn,send_buf,send_nbytes);

        wc=0;

        while (1) {

            pa=PutToRBuf(cn,&cs_BBB,&BBB,send_buf,send_nbytes);

            Log("%03d sent %d bytes\n",cn,pa);

            HexDump(cn,send_buf,pa);

            send_buf+=pa;

            send_nbytes-=pa;

            if (send_nbytes<=0) break;//

            sleep_ms(1000);

            if (No_Loop) break;//

            wc++;

            if (wc>3600) Log("%03d %d==wc>3600!\n",cn,wc);

        }

        if (No_Loop) break;//

    }

#ifndef WIN32

    pthread_exit(NULL);

#endif

}

int main() {

#ifdef WIN32

    InitializeCriticalSection(&cs_log);

    InitializeCriticalSection(&cs_HEX );

    InitializeCriticalSection(&cs_BBB );

#else

    pthread_t threads[2];

    int threadsN;

    int rc;

    pthread_mutex_init(&cs_log,NULL);

    pthread_mutex_init(&cs_HEX,NULL);

    pthread_mutex_init(&cs_BBB,NULL);

#endif

    Log("Start===========================================================\n");



    BBB.head=0;

    BBB.tail=0;

    BBB.size=0;



#ifdef WIN32

    _beginthread((void(__cdecl *)(void *))thdA,0,(void *)1);

    _beginthread((void(__cdecl *)(void *))thdB,0,(void *)2);

#else

    threadsN=0;

    rc=pthread_create(&(threads[threadsN++]),NULL,thdA,(void *)1);if (rc) Log("%d=pthread_create %d error!\n",rc,threadsN-1);

    rc=pthread_create(&(threads[threadsN++]),NULL,thdB,(void *)2);if (rc) Log("%d=pthread_create %d error!\n",rc,threadsN-1);

#endif



    if (!access("No_Loop",0)) {

        remove("No_Loop");

        if (!access("No_Loop",0)) {

            No_Loop=1;

        }

    }

    while (1) {

        sleep_ms(1000);

        if (No_Loop) break;//

        if (!access("No_Loop",0)) {

            No_Loop=1;

        }

    }

    sleep_ms(3000);

    Log("End=============================================================\n");

#ifdef WIN32

    DeleteCriticalSection(&cs_BBB );

    DeleteCriticalSection(&cs_HEX );

    DeleteCriticalSection(&cs_log);

#else

    pthread_mutex_destroy(&cs_BBB);

    pthread_mutex_destroy(&cs_HEX);

    pthread_mutex_destroy(&cs_log);

#endif

    return 0;

}

服务器端用异步处理，客户端用多线程，优化之

so easy！