开多少线程合适？

一群问题 2013-12-17 04:36:16
问题是这样的。

游戏服务器，现有一个比较耗时的操作，每个用户可能都会做该操作。该操作大概耗时最多2秒。我想这么操作。就是把该操作都放在一个线程中处理，即，每操作该步骤，都会创建一个线程独立去处理它。也写了一个统一的管理线程的管理器（如果检测到线程完成了，就close它）。你们觉得这样可行吗？ 如果1000个这样的线程同时创建，是不是问题很大？ 我是想，相对而言，每个线程处理时间都很短，而且也不会有循环，结束了基本上也会被立刻关闭，应该问题不大吧！

这只是我的浅陋想法。一个同事让我用生产者消费者这个线程模型，我不太清楚这个。

大家有什么其他好的方法吗？

谢谢
...全文
1486 26 打赏 收藏 转发到动态 举报
写回复
用AI写文章
26 条回复
切换为时间正序
请发表友善的回复…
发表回复
灯火下的行人 2016-04-15
  • 打赏
  • 举报
 回复
赵4老师，我们的老师
奔跑的大象 2013-12-19
  • 打赏
  • 举报
 回复
引用 2 楼 zhao4zhong1 的回复:
不要动态创建、销毁线程。 要使用线程池。 参考下面：
//循环向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;
}
赵老师无处不在啊
kunkun2013 2013-12-19
  • 打赏
  • 举报
 回复
一般来说2秒且频繁的操作，不是线程能解决的。epoll之类的方式是唯一解决的方式。线程解决的是瞬时并发问题，不是容量问题。既然是游戏，肯定有人写接入端的异步io，你可以请教下团队里写这部分的人。
sololie 2013-12-18
  • 打赏
  • 举报
 回复
开越少越合适
赵4老师 2013-12-18
  • 打赏
  • 举报
 回复
《Windows核心编程》 《深入解析Windows操作系统-Windows Internals》
qq120848369 2013-12-18
  • 打赏
  • 举报
 回复
维护个线程池就可以了，请求丢到池子里跑完再丢回IO线程。
我爱CPP 2013-12-18
  • 打赏
  • 举报
 回复
http也是可以用异步的，只是有可能在你这里修改量太大而已。 对方也不同意修改的话，那你只能开线程池了，线程池的大小可以配置，可以通过调节线程池大小测试出最优的线程数量。
示申○言舌 2013-12-18
  • 打赏
  • 举报
 回复
线程数量公式： 最佳线程数量＝CPU数量×2＋1 因此，初始化时，就把这些线程建好，放到一个容器中进行管理（线程池）。 将操作都看作是一个任务，每个任务都尽可能的短，任务放到队列中。 当任务队列不为空时，激活线程池，分配一个线程去处理第一个任务并将它从队列中清除。 你那个2秒的操作，最好能再分解一下，比如将每一步或没几步分成子操作，用户操作时，就把一些列的子任务放到队列中....
一群问题 2013-12-18
  • 打赏
  • 举报
 回复
引用 12 楼 u013150151 的回复:
[quote=引用 8 楼 zcwtop 的回复:] [quote=引用 4 楼 u013150151 的回复:] 开多少线程得看你的耗时是因为异步等待耗时，还是你的逻辑处理就要2秒。 如果是因为等待（如等待数据库返回，等待其他服务器返回、锁等待等），就可以适当的多一些线程。 但通常不超过CPU核数*4，太多线程性能只会更差。 如果没有任何等待，处理都是耗CPU的，那么线程数与CPU数相同时性能最高。 尽量避免锁得使用，线程之间只用消息队列交互，只对必须的数据加上，数据操作很好性能的情况下，建议将数据分批加锁，建议使用异步架构。 http://blog.csdn.net/u013150151/article/details/17334145
是因为等待的关系，服务器中用到了一个http请求获取数据的东西，所以想让这个步骤放在线程中异步操作，以防阻塞。 只是现在不知道如何设计比较好[/quote] 如果这个http请求消息是自己可以控制的，是自己用socket写的，可以使用异步SOCKET，可以用异步方式来设计。 设计思路跟我博客中写的差不多。 如果这个不好改的话，如果http请求的那个服务器也是你们自己开发的话，可以考虑两边都是服务器，http服务器接到请求后，先直接回请求已经接收的应答，等处理完了后，在向你的这个服务器发送真正的应答。其实也算是一种异步，只不过这种异步是流程上的异步，socket还是同步的。[/quote] 唉，我们要http请求的服务器是别人的，而且目前只可以用http去请求数据。
我爱CPP 2013-12-18
  • 打赏
  • 举报
 回复
引用 8 楼 zcwtop 的回复:
[quote=引用 4 楼 u013150151 的回复:] 开多少线程得看你的耗时是因为异步等待耗时，还是你的逻辑处理就要2秒。 如果是因为等待（如等待数据库返回，等待其他服务器返回、锁等待等），就可以适当的多一些线程。 但通常不超过CPU核数*4，太多线程性能只会更差。 如果没有任何等待，处理都是耗CPU的，那么线程数与CPU数相同时性能最高。 尽量避免锁得使用，线程之间只用消息队列交互，只对必须的数据加上，数据操作很好性能的情况下，建议将数据分批加锁，建议使用异步架构。 http://blog.csdn.net/u013150151/article/details/17334145
是因为等待的关系，服务器中用到了一个http请求获取数据的东西，所以想让这个步骤放在线程中异步操作，以防阻塞。 只是现在不知道如何设计比较好[/quote] 如果这个http请求消息是自己可以控制的，是自己用socket写的，可以使用异步SOCKET，可以用异步方式来设计。 设计思路跟我博客中写的差不多。 如果这个不好改的话，如果http请求的那个服务器也是你们自己开发的话，可以考虑两边都是服务器，http服务器接到请求后，先直接回请求已经接收的应答，等处理完了后，在向你的这个服务器发送真正的应答。其实也算是一种异步，只不过这种异步是流程上的异步，socket还是同步的。
xiao0915 2013-12-18
  • 打赏
  • 举报
 回复
据说有个线程池。。。。。
icosagon 2013-12-18
  • 打赏
  • 举报
 回复
用线程池，如果想快速开发，可以直接用boost.asio这个库自动派发任务到空闲的线程，poco库里也有，自己造也行。 你同事所说的生产者消费者模型不适合这种大量的耗时操作。
漫步者、 2013-12-18
  • 打赏
  • 举报
 回复
那么多线程，到时候资源不够，卡死了！
漫步者、 2013-12-18
  • 打赏
  • 举报
 回复
不知道有个东西叫线程池么？
malone1 2013-12-18
  • 打赏
  • 举报
 回复
线程多少和CPU有关吧,多了反而慢.做个队列,所有线程从队列里面拿请求处理,完了发出去
uploaders 2013-12-18
  • 打赏
  • 举报
 回复
用线程池+任务队列，linux上一个线程分配10M内存，计算一下能分配多少个线程
menzi11 2013-12-18
  • 打赏
  • 举报
 回复
引用 2 楼 zhao4zhong1 的回复:
不要动态创建、销毁线程。 要使用线程池。 参考下面：
//循环向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;
}
大师正好突然想起来了求教个问题啊，windows上使用SubmitThreadpoolWork时，到底是 系统自动为当前进程创建了一个线程池并执行工作，还是当前的进程调用了系统自带的线程池， 像cocoa的GCD那样？windows是整个系统统一有一个线程池来执行所有的程序的线程池job，还是 每个进程都有自己的线程池呢？因为我现在用的类库中自己用几条线程写了个线程池，我想知道 用windows系统自己的线程池有什么好处。多谢了！
menzi11 2013-12-18
  • 打赏
  • 举报
 回复
最近论坛上经常出现线程池相关的问题啊
一群问题 2013-12-17
  • 打赏
  • 举报
 回复
引用 4 楼 u013150151 的回复:
开多少线程得看你的耗时是因为异步等待耗时，还是你的逻辑处理就要2秒。 如果是因为等待（如等待数据库返回，等待其他服务器返回、锁等待等），就可以适当的多一些线程。 但通常不超过CPU核数*4，太多线程性能只会更差。 如果没有任何等待，处理都是耗CPU的，那么线程数与CPU数相同时性能最高。 尽量避免锁得使用，线程之间只用消息队列交互，只对必须的数据加上，数据操作很好性能的情况下，建议将数据分批加锁，建议使用异步架构。 http://blog.csdn.net/u013150151/article/details/17334145
是因为等待的关系，服务器中用到了一个http请求获取数据的东西，所以想让这个步骤放在线程中异步操作，以防阻塞。 只是现在不知道如何设计比较好
SKATE11 2013-12-17
  • 打赏
  • 举报
 回复
线程池适合这种情况 连接多 每个连接的时间又短
加载更多回复（6）
Java多线程快速上手经典
掌握到什么程度、一线架构设计会遇到哪些坑、如何才能做出最合适的架构设计，经验最难得！适应人群：    想要系统、深入学习Java多线程    已有Java开发基础，想要快速掌握Java多线程  &...
一台服务器上启动多少线程合适？
目录 多用户并发访问是网站的基本需求，大型网站的并发用户数会达到数万，单台服务器的并发用户也会达到数百。CGI编程时代，每个用户请求都会创建一个独立的系统进程去处理。由于线程比进程更轻量，更少占用系统资源，切换代价更小，因此网站开发天然就是多线程编程。 那么一台服务器上启动多少线程合适呢？ 公式： 启动线程数=【任务执行时间 / (任务执行时间-IO等待时间）】 * CPU内核数 最佳启动线程数和CPU内核数量成正比，和IO阻塞时间成反比。如果任务都是CPU计算型任务，那么线程数最多不超过CPU内核数，因
创建多少个线程合适？
文章目录创建多少个线程合适？1.为什么要使用多线程？CPU密集型程序I/O密集型程序2.创建多少个线程合适？CPU密集型程序创建多少个线程合适？I/O密集型程序创建多少个线程合适？3.例题：第一题：第二题：增加CPU核心数就一定能解决问题么？ 创建多少个线程合适？ 拾人牙慧，看了一篇博客做做记录。 大佬博客：https://www.jianshu.com/p/f30ee2346f9f 1.为什么要使用多线程？ 相比单线程优势在同时处理多个事件，速度快的时间优势；但多线程也同样容易出问题。 合适的场景+合适的
一个并发程序开多少线程合适？
文章来源：http://blog.csdn.net/greencacti/article/details/5881964 最近在和朋友讨论的过程中，朋友说线程开得多性能好，理由是系统中已经有成百上千的线程，并发程序开的线程越多分配到CPU的概率越高。我不认可该观点，下面来验证。 最好起CPU核心数量*2 个线程 或者 CPU核心数量*2 +2 个线程 测试场景： 硬件：HP G6(8
6.线程池中有多少线程合适？
如何确定线程池中指定多少线程合适？ 线程池确实可以减少线程创建和销毁的开销，提高效率，可以复用线程。但是一个线程池中应该指定多少线程合适呢？指定多少核心线程，最大线程数设置为多少合适呢？ 其实具体的线程数量需要根据不同的服务器和不同的使用场景确定的，脱离了场景去说线程池指定多少线程合适是没有意义的。 1. 常见场景 一般情况下，我们的实际场景跳不出这个三个场景： 1. IO密集型 线程池中的大多数任务都是执行IO操作的。IO操作时需要比较长时间的等待的，对于CPU的利用率并不高。所以这时候可以适当的多指定
C++ 语言

64,682

社区成员

250,490

社区内容

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

加载中

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

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

+ 用AI写文章