对于C/C++标准库的线程安全的一个疑问。
VC的C/C++标准库里面,malloc/calloc/new是不是默认线程安全的?
也就说，在一个进程内，同时只有一个线程能访问malloc/calloc/new/delete/free，其他的线程对这几个函数的调用都是有同步保护的? C/C++标准库里面有这种访问锁机制么?
[解决办法]
这几个是线程安全的把？不然多线程程序怎么写啊？
[解决办法]
仅供参考
- C/C++ code
//循环向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 2char 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;}
[解决办法]
malloc/free本身具有原子性是线程安全的。
而new/delete虽然不具备原子性，但是在分配内存区域的过程是原子性的，之后的操作区域别的线程无法获取，也应该是线程安全的。
[解决办法]
线程安全，就是可重入的意思。malloc/calloc/new/delete/free这还用问吧？基本操作符还要问是不是线程安全呢？
通常问的是time.h里的那些函数是不是线程安全的，如tm t = *time(NULL),从没听过你这样问的。
int a;
int doSomething()
{
return a+1;
}
由于使用了全局变量a，所以不可重入。
int doSomthing(int a)
{
return a+1;
}
这个函数与外界无关，就是可重入的。
[解决办法]
使用 Intel® Threading Building Blocks
性能卓越。
常用的，都有了。。
[解决办法]
malloc/free本身具有原子性是线程安全的。
new/delete本质上是调用malloc/free，只要你用了多线程运行库自然就线程安全了
[解决办法]
必须安全的
[解决办法]
测试用的吧。