请高手帮忙解决一下生产者消费者有关问题，请看具体内容再回答

请高手帮忙解决一下生产者消费者问题，请看具体内容再回答
一个server要将从另一个server收到的消息发送到多个client，为减少延迟，对每个client分配一个消息处理对象；
这个对象维护了一个消息队里，这个队里保存从server收到的消息，同时这个对象里有个线程从这个队列里取消息发送给相应客户端。
目前这个队列使用了条件变量和锁来保证线程安全和不让消息处理线程在队列为空时空运转导致占有100%CPU。
但是这个消息队列会产生很大的延时，而且当客户端增多时，消息延时会更加大。
如果使用lockfree的队列时会导致CPU占有率高。

高手们，你们是怎么处理这个问题的？
有什么好的设计模式来处理这个问题吗？
------解决方案--------------------
取消息的函数可以用阻塞函数，就像Windows的GetMessage()函数一样
------解决方案--------------------
你可以先看下延迟由哪一部分造成的
------解决方案--------------------
有个问题: 
收到的消息发个多个客户是不是指每收到一条消息都要转发给每一个客户？
还是根据消息里的目的地转发给某一个客户？
------解决方案--------------------
仅供参考

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

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

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

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <windows.h>

#include <process.h>

#include <io.h>

//Log{

#define MAXLOGSIZE 10000000

#define ARRSIZE(x) (sizeof(x)/sizeof(x[0]))

#include <time.h>

#include <sys/timeb.h>

#include <stdarg.h>

char logfilename1[]="MyLog1.log";

char logfilename2[]="MyLog2.log";

char logstr[16000];

char datestr[16];

char timestr[16];

char mss[4];

CRITICAL_SECTION cs_log;

FILE *flog;

void Lock(CRITICAL_SECTION *l) {

    EnterCriticalSection(l);

}

void Unlock(CRITICAL_SECTION *l) {

    LeaveCriticalSection(l);

}

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

    struct tm *now;

    struct timeb tb;


    if (NULL==pszFmt
------解决方案--------------------
0==pszFmt[0]) return;

    if (-1==_vsnprintf(logstr,ARRSIZE(logstr),pszFmt,argp)) logstr[ARRSIZE(logstr)-1]=0;

    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);

            }

            flog=fopen(logfilename1,"a");

            if (NULL==flog) return;

        }

        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++) {