怎么接受并处理udp协议快速发送过来的数据！

幸运的铁匠 2015-07-06 09:35:41
仪器通过udp协议发送数据每秒大概4M但我程序数据处理的部分很慢，请各位大神指导一下啊怎么处理!很着急！！
...全文
2578 21 打赏 收藏 转发到动态 举报
写回复
用AI写文章
21 条回复
切换为时间正序
请发表友善的回复…
发表回复
wj302763621 2017-12-11
  • 打赏
  • 举报
 回复
引用 19 楼 zhouqinghe24 的回复:
[quote=引用 15 楼 wj302763621 的回复:] [quote=引用 8 楼 zhouqinghe24 的回复:] 我用了一个 内存队列 和 redis 队列 处理过秒100万的udp 数据接收. 测试一个包都不丢(程序丢包) 使用了分布式处理方式. 一台服务器 专门接收udp 数据包,然后先保存在内存list 中 每10毫秒 批量插入redis 队列 另一台(或N台)服务器开启多个线程 从redis 队列中 取出数据 去处理.这样 只要接收服务器 能承受, 随时可以 配置多台处理的服务器,每个服务器的线程数也是可以通过配置来控制.
这个是假的吧 ？？？[/quote] 这是当时在生产用的策略 ,真假自知! [/quote] 这个方案到时真的，这个100万的数据是指100万条UDP消息么 ？？
赵4老师 2017-12-07
  • 打赏
  • 举报
 回复
引用 17 楼 zhao4zhong1 的回复:
仅供参考：
//循环向a函数每次发送200个字节长度（这个是固定的）的buffer,
//a函数中需要将循环传进来的buffer，组成240字节（也是固定的）的新buffer进行处理，
//在处理的时候每次从新buffer中取两个字节打印
#ifdef _MSC_VER
    #pragma warning(disable:4996)
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifdef _MSC_VER
    #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 _MSC_VER
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,struct 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 _MSC_VER
    pthread_exit(NULL);
#endif
}
int PutToRBuf(int cn,CRITICAL_SECTION *cs,struct 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 _MSC_VER
    pthread_exit(NULL);
#endif
}
int main() {
#ifdef _MSC_VER
    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 _MSC_VER
    _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 _MSC_VER
    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;
}
任何收发两端速度不一致的通讯，都需要在它们之间使用一个足够大的FIFO缓冲区。 对任何FIFO缓冲区的使用，都需要仔细考虑接收端接收时超时无数据和发送端发送时FIFO缓冲区已满这两种情况下该如何做。 这些概念都在这段经典代码中有所体现。 这段经典代码还包括以下必须考虑的因素： ◆跨Windows和Linux平台 ◆多线程锁 ◆多线程日志 ◆日志文件占用的磁盘空间可控 ◆日志中的时间包括毫秒 ◆传输的数据对应的每个字节到底是几 ◆如何退出多线程程序 ◆……
瑞卡哥哥 2017-12-06
  • 打赏
  • 举报
 回复
引用 15 楼 wj302763621 的回复:
[quote=引用 8 楼 zhouqinghe24 的回复:] 我用了一个 内存队列 和 redis 队列 处理过秒100万的udp 数据接收. 测试一个包都不丢(程序丢包) 使用了分布式处理方式. 一台服务器 专门接收udp 数据包,然后先保存在内存list 中 每10毫秒 批量插入redis 队列 另一台(或N台)服务器开启多个线程 从redis 队列中 取出数据 去处理.这样 只要接收服务器 能承受, 随时可以 配置多台处理的服务器,每个服务器的线程数也是可以通过配置来控制.
这个是假的吧 ？？？[/quote] 这是当时在生产用的策略 ,真假自知!
赵4老师 2017-11-24
  • 打赏
  • 举报
 回复
仅供参考：
//循环向a函数每次发送200个字节长度（这个是固定的）的buffer,
//a函数中需要将循环传进来的buffer，组成240字节（也是固定的）的新buffer进行处理，
//在处理的时候每次从新buffer中取两个字节打印
#ifdef _MSC_VER
    #pragma warning(disable:4996)
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifdef _MSC_VER
    #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 _MSC_VER
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,struct 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 _MSC_VER
    pthread_exit(NULL);
#endif
}
int PutToRBuf(int cn,CRITICAL_SECTION *cs,struct 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 _MSC_VER
    pthread_exit(NULL);
#endif
}
int main() {
#ifdef _MSC_VER
    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 _MSC_VER
    _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 _MSC_VER
    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;
}
xiaohuh421 2017-11-24
  • 打赏
  • 举报
 回复
空间与时间的问题. 你要处理快, 那么就只能多占缓存空间. 要少缓存空间, 那么必然处理就慢了. 可以开启一个线程, 专门收数据, 收到数据放到缓冲区中或者队列中, 这个过程应该是非常快的, 肯定会快过一般的网络传输速度. 然后再开一个线程来专门处理数据, 数据处理一般会比较慢. 这样一来, 你就要权衡了, 因为生产得快, 消费得慢, 必然导致内存占用疯涨. 所以变成时间与空间的问题了.
wj302763621 2017-11-23
  • 打赏
  • 举报
 回复
引用 8 楼 zhouqinghe24 的回复:
我用了一个 内存队列 和 redis 队列 处理过秒100万的udp 数据接收. 测试一个包都不丢(程序丢包) 使用了分布式处理方式. 一台服务器 专门接收udp 数据包,然后先保存在内存list 中 每10毫秒 批量插入redis 队列 另一台(或N台)服务器开启多个线程 从redis 队列中 取出数据 去处理.这样 只要接收服务器 能承受, 随时可以 配置多台处理的服务器,每个服务器的线程数也是可以通过配置来控制.
这个是假的吧 ？？？
大尾巴猫 2017-11-23
  • 打赏
  • 举报
 回复
加锁解锁本身的动作，是很快的（尤其是对于你说的每秒4M的数据来不及处理）。 你说的读取数据处理很费时而影响到接收速度，明显还是逻辑处理的问题，还是单线程的思路。 看起来你接收到一块缓存，然后用另外的线程加锁处理这一块缓存，然而接收线程由于这块缓存被锁而无法接收。这和单线程有啥区别。 这肯定不行。要用缓存队列或者链表之类的。 接收一块缓存，加锁，入队列，解锁。然后接收新new的缓存。 多个处理线程加锁，从队列中取一块缓存，解锁，处理数据。delete缓存，再重复。 当然，涉及到多个处理线程如何正确的分包，粘包，这是另外的事情了。
幸运的铁匠 2015-07-06
  • 打赏
  • 举报
 回复
引用 1 楼 zhouqinghe24 的回复:
udp 数据是不可靠的 所以接收速度要快. 接收的数据可以先不用处理. 启动一个子线程 只管接收数据 ,然后 放入 一个队列中 (或者链表 都可以) 然后启动多个子线程 来处理. 这样就不会丢失数据了.
几个线程如何同时操作一个队列里的数据呢？这个具体我不太清楚望指教，谢谢！
幸运的铁匠 2015-07-06
  • 打赏
  • 举报
 回复
引用 2 楼 lianshaohua 的回复:
接收，放入缓存（内存队列等），然后用几个线程处理
但是处理速度肯还是更不上接受速度的，这样怎么处理呢？
幸运的铁匠 2015-07-06
  • 打赏
  • 举报
 回复
引用 1 楼 zhouqinghe24 的回复:
udp 数据是不可靠的 所以接收速度要快. 接收的数据可以先不用处理. 启动一个子线程 只管接收数据 ,然后 放入 一个队列中 (或者链表 都可以) 然后启动多个子线程 来处理. 这样就不会丢失数据了.
您好，我一开始思路是这样的，一个线程接收数据放入一个循环缓冲区，当数据到达一定量后再触发运算线程取走数据并进行运算，可是在运算这段时间由于设置了临界保护区所以接受部分线程是不能写数据的。我的疑问是如何让接受线程不停处理线程也能处理接受的数据，两个线程同时操作一个队列不会出问题吗？
fly_dragon_fly 2015-07-06
  • 打赏
  • 举报
 回复
数据处理重开一个进程
ztenv 版主 2015-07-06
  • 打赏
  • 举报
 回复
接收，放入缓存（内存队列等），然后用几个线程处理
瑞卡哥哥 2015-07-06
  • 打赏
  • 举报
 回复
udp 数据是不可靠的 所以接收速度要快. 接收的数据可以先不用处理. 启动一个子线程 只管接收数据 ,然后 放入 一个队列中 (或者链表 都可以) 然后启动多个子线程 来处理. 这样就不会丢失数据了.
日立奔腾浪潮微软松下联想 2015-07-06
  • 打赏
  • 举报
 回复
不需要这么复杂，双缓冲区接收数据，处理线程设置一个标志表明正在处理哪个缓冲区，接收线程读这个标志，向空闲的那个缓冲区写数据就可以了。
幸运的铁匠 2015-07-06
  • 打赏
  • 举报
 回复
引用 11 楼 u012286517 的回复:
[quote=引用 10 楼 lianshaohua 的回复:] [quote=引用 5 楼 u012286517 的回复:] [quote=引用 2 楼 lianshaohua 的回复:] 接收，放入缓存（内存队列等），然后用几个线程处理
但是处理速度肯还是更不上接受速度的，这样怎么处理呢？[/quote] 如果的确是这样，如果不是程序设计的问题——就是CPU真的不够用了，增加硬件吧，[/quote] 可以帮忙看下代码么?[/quote] 哦哦！，请问c++下可不可以不加锁的情况下实现同时对队列读写操作呢？因为我的读取数据处理那块很费时如果加锁会影响接受速度而造成丢包
幸运的铁匠 2015-07-06
  • 打赏
  • 举报
 回复
引用 10 楼 lianshaohua 的回复:
[quote=引用 5 楼 u012286517 的回复:] [quote=引用 2 楼 lianshaohua 的回复:] 接收，放入缓存（内存队列等），然后用几个线程处理
但是处理速度肯还是更不上接受速度的，这样怎么处理呢？[/quote] 如果的确是这样，如果不是程序设计的问题——就是CPU真的不够用了，增加硬件吧，[/quote] 可以帮忙看下代码么?
瑞卡哥哥 2015-07-06
  • 打赏
  • 举报
 回复
做压力测试的话 把你的Sleep(1)和OutputDebugString 都去掉 最耗时的地方 就是IO操作 而Sleep(1) 在windows 下是1毫秒 1秒钟最多接收1000条数据 linux 上是微秒级的 也会因为这个操作影响接收速度.
ztenv 版主 2015-07-06
  • 打赏
  • 举报
 回复
引用 5 楼 u012286517 的回复:
[quote=引用 2 楼 lianshaohua 的回复:] 接收，放入缓存（内存队列等），然后用几个线程处理
但是处理速度肯还是更不上接受速度的，这样怎么处理呢？[/quote] 如果的确是这样，如果不是程序设计的问题——就是CPU真的不够用了，增加硬件吧，
幸运的铁匠 2015-07-06
  • 打赏
  • 举报
 回复
引用 8 楼 zhouqinghe24 的回复:
我用了一个 内存队列 和 redis 队列 处理过秒100万的udp 数据接收. 测试一个包都不丢(程序丢包) 使用了分布式处理方式. 一台服务器 专门接收udp 数据包,然后先保存在内存list 中 每10毫秒 批量插入redis 队列 另一台(或N台)服务器开启多个线程 从redis 队列中 取出数据 去处理.这样 只要接收服务器 能承受, 随时可以 配置多台处理的服务器,每个服务器的线程数也是可以通过配置来控制.
这是我的写的部分代码，但这样速度完全达不到，请问是什么原因呢？ //数据接收线程 UINT ReciveThread(LPVOID params) { OutputDebugString(">>>> Start ReceiveThread...\r\n"); CDTUDlg *pDlg = (CDTUDlg *)params; int err = 0; int sockaddrlen = 0; sockaddrlen = sizeof(pDlg->s_RemoteAddr); while(theApp.m_bLooping) { //通过udp接收数据 OutputDebugString(">>>> ReciveThread WaitForSingleObject : m_hEvent_ProcessingEnd\r\n"); //::WaitForSingleObject(theApp.m_hEvent_ProcessingEnd,INFINITE); OutputDebugString("recvfrom...\r\n"); for(int i=0;i<10;i++) { err = recvfrom( //返回正确接收的字节数 pDlg->UDPSocket, /* receive UDP data */ pDlg->RecMsg.msg, sizeof(pDlg->RecMsg.msg), 0, (sockaddr *)&pDlg->s_RemoteAddr, (int *)&sockaddrlen ); if (err == SOCKET_ERROR) /* Is receive data right */ { return 0; } pDlg->RecMsg.len = err; //互斥的访问缓冲区 for(int i=0;i<pDlg->RecMsg.len;i++)//将数据放入缓存 { EnterCriticalSection(&theApp.g_cs); theApp.dataBuffer.push(pDlg->RecMsg.msg[i]); LeaveCriticalSection(&theApp.g_cs); } } Sleep(1); } return 1; } //数据处理线程 UINT ProcessDataThread(LPVOID params) { OutputDebugString(">>>> Start ProcessDataThread...\r\n"); CDTUDlg *pDlg = (CDTUDlg *)params;//point to Dlg while(theApp.m_bLooping) { for(int i=0;i<10;i++) { if(theApp.dataBuffer.size()>=4114) { EnterCriticalSection(&theApp.g_cs); pDlg->get();//解析数据 LeaveCriticalSection(&theApp.g_cs); pDlg->RecHandle();//处理数据 } } return 0; }
瑞卡哥哥 2015-07-06
  • 打赏
  • 举报
 回复
我用了一个 内存队列 和 redis 队列 处理过秒100万的udp 数据接收. 测试一个包都不丢(程序丢包) 使用了分布式处理方式. 一台服务器 专门接收udp 数据包,然后先保存在内存list 中 每10毫秒 批量插入redis 队列 另一台(或N台)服务器开启多个线程 从redis 队列中 取出数据 去处理.这样 只要接收服务器 能承受, 随时可以 配置多台处理的服务器,每个服务器的线程数也是可以通过配置来控制.
加载更多回复（1）
计算机网络 传输层 TCP和UDP协议
Re： 计算机网络 传输层 TCP和UDP协议# 传输层协议 TCP 和 UDP 的应用场景 要发送的内容多，需要将发送的内容分成多个数据包发送（TCP） 要发送的内容少，一个数据包就能发送全部内容（UDP）# 传输层协议和应用层协议之间的关系 传输层协议加一个端口号来标识一个应用层协议， 展示了传输层协议和应用层协议之间的关系# 使用TCP/IP筛选实现网络安全 防火墙设置与端口# UDP协议特点和报文格式UDP是无连接的：即发送数据之前不需要建立连接UDP使用尽最大努力交付：即不保证可靠交付，因此主机不需要维持复杂的连接状态表# TCP 协议特点和报文格式先连接后释放；点对点；可靠传输；全双工通信；面向数据流七项标记位停止等待协议与改进的停止等待协议滑动窗口技术详解：确认Seq与选择确认SACK 超时重传时间：查询计算与自动调整 流量控制功能：点对点的流量控制  拥塞控制：相对整体网络环境而言；慢开始算法和拥塞避免算法 改进的拥塞控制：快重传和快恢复 三次握手建立TCP连接，四次挥手释放连接。# TCP 协议面临的攻击 SYN 攻击：捏造的源地址； LAND攻击：自己就是源地址# 通过抓包工具，查看以上报文格式# 习题详解  
UDP和TCP协议发送接收数据
一.UDP协议发送接收数据(不需要建立连接,不可靠协议)1.(客户端)发送数据步骤:2.(服务端)接收数据步骤:3.实现客户端键盘录入,服务端控制台输出(多线程)4.实现双方互聊(多线程) 二.TCP协议发送接收数据(必须建立连接,可靠协议,效率稍低)1.(客户端)发送数据步骤:2.(服务端)接收数据步骤:3.实现客户端键盘录入,服务端控制台输出4.客户端键盘录入,服务端写到文本文件中5. 客户端读取文档,服务端接收并存入文档且有反馈 UDP协议: 发短信 ​ 将数据源和目的地封装成数据包，不需要建立连接；
UDP协议发送/接收数据实现[TCP/IP协议入门]
背景 Demo 基于 Java 实现简单的 UDP 传输 / 接收协议 词义百科 UDP 协议（用户数据包协议） UDP 是无连接通信协议，即在数据传输时，数据的发送端和接收端不建立逻辑连接，简单来说，当客户端向接收端发送数据时，客户端不会确认接收端是否存在，就会发出数据。同样接收端在接收数据时，也不会向发送端反馈是否收到数据 由于使用 UDP 协议消耗资源小，通信效率高，所以通常都会用于音频、视频和普通数据传输 例如：视频会议通常采用 UDP 协议，因为这种情况即使偶尔丢失一两个数据包，也不会对接收结果产
Java 网络编程UDP协议之发送数据和接收数据的详解
UDP协议： 用户数据报协议(User Datagram Protocol) UDP是无连接通信协议，即在数据传输时，数据的发送端和接收端不建立逻辑连接。简单来说，当一个台计算机向另外一台计算机发送数据时，发送端不会确认接收端是否存在，就会发出数据，同样接收端在收到数据时，也不会向发送端反馈是否收到数据。由于使用UDP协议消耗资源少，通信效率高，所以通常都会用于音频，视频和普通数据的传输。 例如视频会议通常会采用UDP协议，因为这种情况偶尔丢一两个数据包，也不会对接收结果产生太大影响，但是在使用UDP协议
Java使用UDP协议发送和接收数据
Java使用UDP协议发送和接收数据
C++ 语言

64,631

社区成员

250,898

社区内容

发帖
与我相关
我的任务
社区描述
C++ 语言相关问题讨论，技术干货分享，前沿动态等
c++ 技术论坛（原bbs）
社区管理员
  • C++ 语言社区
  • encoderlee
  • paschen
加入社区
  • 近7日
  • 近30日
  • 至今

加载中

查看更多榜单
社区公告
  1. 请不要发布与C++技术无关的贴子
  2. 请不要发布与技术无关的招聘、广告的帖子
  3. 请尽可能的描述清楚你的问题，如果涉及到代码请尽可能的格式化一下

试试用AI创作助手写篇文章吧

+ 用AI写文章