线程效率问题

2012-09-07 11:34:53 135 阅读 AI 写同款 · GEO 优化AI 选题数据监测一键分发 ›

基于TL431与光耦的电压反馈环路优化设计实战本文深入探讨了基于TL431与光耦的电压反馈环路优化设计实战。文章从理解这对“黄金搭档”的工作原理入手，详细拆解了电压采样电阻网络、偏置电路、光耦工作点设置以及动态补偿网络的设计心法与计算步骤。重点分享了如何通过RC补偿网络调试，确保环路在各种负载下稳定可靠，并提供了关键的实战避坑指南，帮助工程师解决电源设计中常见的振荡、噪声及可靠性问题。阅读详情

版本一：
有一个日志类
有A,B,C,D....等线程，每个线程需要时就去调用日志类打印日志。

版本二：
有个日志类，自己有一个监控线程，查看内部的一个日志消息队列，如有日志消息就Pop打印，没有就睡眠。
有A,B,C,D.....等线程，每个线程有需要就将日志消息push到日志类的消息队列中。

版本一和版本二的效率到底那个好点？

在版本二中，我还可以控制，当队列的消息数据字节达到一定值的时候才去pop打印，这样就起到了一个先将消息缓存，然后到达一定量时，才去打印，节省了IO时间，但是在控制方面，遇到很多问题。
我的想法是使用2个队列，2个队列的状态一定是一个pop状态，一个是push状态，当pop状态的队列消息为0并且push状态的消息队列到达一定字节时，转换状态....

看到win32中的线程消息队列，和界面里涉及的消息队列，我想知道里面的具体实现和原理，有谁跟我说说不？

...全文

高频面试题-项目介绍篇聊聊如何介绍项目经历。阅读详情

版主大哥

C++ 语言 65,214 成员 250,514 内容

+ 关注 + 加入社区

切换为时间正序

版主大哥 2012-09-07

打赏
举报

[Quote=引用 2 楼的回复:]

楼主基础根本没掌握，连正规的实现方法都想不出来。

1，加锁并发写，没问题。
2，全部推到一个点，顺序写入，也没问题。

对于问题2，你了解一下select+pipe+queue的首先手法，再了解一下udp socket以及msg queue，这里不适合阻塞模型（mutex+cond）。最后，你有兴趣了解更有意思的东西，学一下rabbitmq。
[/Quote]
能否再详细点？谢谢

赵4老师 2012-09-07

打赏
举报

//循环向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++) {

                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;

}

void 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(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(1);

            } else {

                Sleep(1000);

            }

            if (No_Loop) break;//

            wc++;

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

        }

        if (No_Loop) break;//

    }

}

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;

}

void 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(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(1000);

            if (No_Loop) break;//

            wc++;

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

        }

        if (No_Loop) break;//

    }

}

int main() {

    InitializeCriticalSection(&cs_log );

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

    InitializeCriticalSection(&cs_HEX );

    InitializeCriticalSection(&cs_BBB );



    BBB.head=0;

    BBB.tail=0;

    BBB.size=0;



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

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



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

        remove("No_Loop");

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

            No_Loop=1;

        }

    }

    while (1) {

        Sleep(1000);

        if (No_Loop) break;//

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

            No_Loop=1;

        }

    }

    Sleep(3000);

    DeleteCriticalSection(&cs_BBB );

    DeleteCriticalSection(&cs_HEX );

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

    DeleteCriticalSection(&cs_log );

    return 0;

}

赵4老师 2012-09-07

打赏
举报

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#ifdef WIN32

    #include <windows.h>

    #include <io.h>

#else

    #include <unistd.h>

    #include <sys/time.h>

    #include <pthread.h>

    #define  CRITICAL_SECTION   pthread_mutex_t

    #define  _vsnprintf         vsnprintf

#endif

//Log{

#define MAXLOGSIZE 20000000

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

#ifdef WIN32

void Lock(CRITICAL_SECTION *l) {

    EnterCriticalSection(l);

}

void Unlock(CRITICAL_SECTION *l) {

    LeaveCriticalSection(l);

}

#else

void Lock(CRITICAL_SECTION *l) {

    pthread_mutex_lock(l);

}

void Unlock(CRITICAL_SECTION *l) {

    pthread_mutex_unlock(l);

}

#endif

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}

int main(int argc,char * argv[]) {

    int i;

#ifdef WIN32

    InitializeCriticalSection(&cs_log);

#else

    pthread_mutex_init(&cs_log,NULL);

#endif

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

        Log("This is a Log %04d from FILE:%s LINE:%d\n",i, __FILE__, __LINE__);

    }

#ifdef WIN32

    DeleteCriticalSection(&cs_log);

#else

    pthread_mutex_destroy(&cs_log);

#endif

    return 0;

}

qq120848369 2012-09-07

打赏
举报

楼主基础根本没掌握，连正规的实现方法都想不出来。

1，加锁并发写，没问题。
2，全部推到一个点，顺序写入，也没问题。

对于问题2，你了解一下select+pipe+queue的首先手法，再了解一下udp socket以及msg queue，这里不适合阻塞模型（mutex+cond）。最后，你有兴趣了解更有意思的东西，学一下rabbitmq。

Gloveing 2012-09-07

打赏
举报

典型的生产者消费者的同步问题

线程效率问题

相关推荐