STL中的list是否是线程安全的？

[bugyouth]

我用多线程来操作list,但老是莫名其妙地崩溃，查了很长时间没有查到原因。STL中的list是否是线程安全的？在多线程操作list时，应当注意什么？

[9731boy]

如果是操作公用内存的话.最好用互斥

[bugyouth]

我已经在线程函数中设置了Event

[bugyouth]

up

[9731boy]

list 应该是线程安全的.应该是你的互斥没有做好.
另外也有可能是你程序其他方面的问题.你可以一步步的排除看看

[hzhxxx]

应该是安全的, STL 自己说的啊

[oyljerry]

估计还是要看看线程方面的处理有没有问题

[DentistryDoctor]

STL是线程安全的，对于list，所谓的线程安全也只是说的它的链表操作，对于在线程间共享的数据，无论什么情况你都应该使用同步机制加以保护，如果不跨进程，临界区是很好的选择。

[bugyouth]

各位有没有一个详细且可用的例子，让我学习一下。分数不是问题。

[yinzhaohui]

不是多线程安全的
The SGI implementation of STL is thread-safe only in the sense that simultaneous accesses to distinct containers are safe, and simultaneous read accesses to to shared containers are safe. If multiple threads access a single container, and at least one thread may potentially write, then the user is responsible for ensuring mutual exclusion between the threads during the container accesses.

This is the only way to ensure full performance for containers that do not need concurrent access. Locking or other forms of synchronization are typically expensive and should be avoided when not necessary.

It is easy for the client or another library to provide the necessary locking by wrapping the underlying container operations with a lock acquisition and release. For example, it would be possible to provide a locked_queue container adapter that provided a container with atomic queue operations.

[yinzhaohui]

#pragma once

template <class TYPE>
class CYQueueSyn
{
public:
std::list<TYPE> queue;
int m_outtime;
HANDLE m_readSem;
HANDLE m_writeSem;
HANDLE m_synObject;

public:
CYQueueSyn(int length,int outtime=INFINITE);
virtual ~CYQueueSyn(void);
public:
void inq(TYPE type);
TYPE outq();
void free();

};

template<class TYPE>
void CYQueueSyn<TYPE>::free()
{
int size=(int)queue.size();
for(int i=0;i<size;i++)
delete queue.back();
queue.clear();
}

template<class TYPE>
CYQueueSyn<TYPE>::CYQueueSyn(int length,int outtime)
{
m_readSem=CreateSemaphore(NULL,0,length,NULL);
m_writeSem=CreateSemaphore(NULL,length,length,NULL);
m_synObject=::CreateMutex(NULL,false,NULL);
}

template<class TYPE>
CYQueueSyn<TYPE>::~CYQueueSyn()
{
CloseHandle(m_readSem);
CloseHandle(m_writeSem);
CloseHandle(m_synObject);
}

template<class TYPE>
void CYQueueSyn<TYPE>::inq(TYPE type) throw(CYException)
{
int rVal=WaitForSingleObject(m_writeSem,m_outtime);

if(rVal==WAIT_OBJECT_0)
{
if(WaitForSingleObject(m_synObject,INFINITE)==WAIT_OBJECT_0)
{
queue.push_back(type);
ReleaseMutex(m_synObject);
}
}
else if(rVal==WAIT_TIMEOUT)
{
throw CYException("1 TIMEOUT");
}
else if(rVal==WAIT_ABANDONED)
{
throw CYException("-1 ERROR");
}
ReleaseSemaphore(m_readSem,1,NULL);
}

template<class TYPE>
TYPE CYQueueSyn<TYPE>::outq() throw(CYException)
{
TYPE value;
int rVal=WaitForSingleObject(m_readSem,m_outtime);
if(rVal==WAIT_OBJECT_0)
{
if(WaitForSingleObject(m_synObject,INFINITE)==WAIT_OBJECT_0)
{
value=queue.front();
queue.pop_front();
ReleaseMutex(m_synObject);
}
}
else if(rVal==WAIT_TIMEOUT)
{
throw CYException("1 TIMEOUT");
}
else if(rVal==WAIT_ABANDONED)
{
throw CYException("-1 ERROR");
}
ReleaseSemaphore(m_writeSem,1,NULL);
return value;
}

[bugyouth]

多谢，您的程序没有出现过崩溃情况吗？
再加100分，继续

[yinzhaohui]

用例
int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
//int CALLBACK WinMain(HINSTANCE hInstance,HINSTANCE hpreInstance,LPSTR cmdLine,int cmdcount)
{

int nRetCode = 0;

// 初始化 MFC 并在失败时显示错误
if (!AfxWinInit(::GetModuleHandle(NULL), NULL, ::GetCommandLine(), 0))
{
// TODO: 更改错误代码以符合您的需要
_tprintf(_T("致命错误: MFC 初始化失败\n"));
nRetCode = 1;
}
else
{
// TODO: 在此处为应用程序的行为编写代码。
test();
}
return nRetCode;
}


typedef struct str_data
{
int a;
CString str;
}Data;

typedef CYQueueSyn<Data*> Queue;

unsigned int __stdcall threadin(void *param)
{
Queue *pqueue=(Queue *)param;
for(int i=0;i<1000;i++)
{
Data *data=new Data();
data->a=i;
data->str.Format("data=%d",i);
pqueue->inq(data);
//Sleep(100);
}

Data *data=new Data();
data->a=-1;
pqueue->inq(data);
printf("in end!\n");
return 0;
}

unsigned int __stdcall threadout(void *param)
{
Queue *pqueue=(Queue *)param;
Data *pdata;
while(1)
{
try
{
pdata=pqueue->outq();
if(pdata->a==-1)
throw CYException("end");
printf("%d %s\n",pdata->a,pdata->str);
delete pdata;
}
catch(...)
{
delete pdata;
break;
}
}
printf("out end!\n");
return 0;
}

void test()
{
Queue queue(1000);
HANDLE thread[20];
unsigned int threadId[20];
for(int i=0;i<10;i++)
{
thread[i]=(HANDLE)_beginthreadex(NULL,0,threadin,&queue,0,&threadId[i]);
}

for(int i=10;i<20;i++)
{
thread[i]=(HANDLE)_beginthreadex(NULL,0,threadout,&queue,0,&threadId[i]);
}
WaitForMultipleObjects(20,thread,true,INFINITE);
}