自己实现的STL（试图解决多线程的安全问题）

最新推荐文章于 2021-04-15 23:44:53 发布
最新推荐文章于 2021-04-15 23:44:53 发布
阅读量786 收藏
点赞数
分类专栏： C++/VC++/MFC 文章标签： 多线程 delete null object list class
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/geshanvictor/article/details/6581446
版权

///

作者:  gavin  葛

时间: 2011年

地点:北京

///

 

 

话说STL在多线程下的不安全，解决其方法有二:

1.在使用的时候,给本身容器总体的加锁,

2.在本身实现STL的时候就加锁.

于是满怀信心的想利用第二种思路自己写一套STL出来(用单项list实现了List 和Deque).

想就这个机会去解决线程不安全的问题,虽然没有达到预期的效果,但是,还想继续在这方面努力.把源代码贴出来,请各位高手多多指教.

(全部代码一个文件中,直接拷贝用就可以)

 

#ifndef  MYSTL
#define MYSTL

namespace MYSTL
{
template <class T>
class CNode
{
private:
 T m_value;
 CNode<T>* m_pNext;
 int m_idx;
public: 
 CNode(T v = 0 , CNode<T>* pnext = NULL,int index=0)
 {
  m_value = v;
  m_pNext = pnext;
  m_idx = index;
 }
 ~CNode(){}
 inline bool SetNode(T v)
 {
  m_value = v;
  return true;
 }
 inline T GetNode()
 {
  return m_value;
 }
 inline CNode<T>* GetNext()
 {
  return m_pNext;
 }
 inline void SetNext(CNode<T>* node)
 {
  m_pNext = node;
 }
 inline void SetIndex(int index)
 {
  m_idx = index;
 }
 inline int GetIndex()
 {
  return m_idx;
 }
};

template<class T>
class CDeque
{
private:
 CNode<T>* m_pHead;
 CNode<T>* m_pTail;
 CNode<T>* m_pCurrent;
 volatile long m_isize;
 volatile long m_bResourseInUse;
 CRITICAL_SECTION critical_sec_object;
private:
 void Lock();
 void UnLock();
public:
 CDeque();
 ~CDeque();
public:
 int GetSize();
 bool PushBack(T value);
 bool PushFront(T value);
 T PopBack();
 T PopFront();
 T GetAt(int idx); 
 bool SetAt(int idx,T value);
 bool InsertAt(int idx,T value);
 bool DeleteAt(int idx);
 bool Erase(int idxBegin);
 bool Clear();
};

template<class T>
class CList
{
private:
 CNode<T>* m_pHead;
 CNode<T>* m_pTail;
 CNode<T>* m_pCurrent;
 volatile long m_isize;
 volatile long m_bResourseInUse;
private:
 void Lock();
 void UnLock();
public:
 CList();
 ~CList();
public:
 int GetSize();     
 T GetAt(int idx);
 bool SetAt(int idx,T value);
 bool InsertAt(int idx,T value);
 bool DeleteAt(int idx);
 bool Erase(int idxBegin);
 bool Clear();
};

template<class T>
CDeque<T>::CDeque()
{
 m_pHead = NULL;
 m_pTail =NULL;
 m_pCurrent = NULL;
 m_isize = 0;
 m_bResourseInUse = FALSE;
 ::InitializeCriticalSection(&critical_sec_object);
}

template<class T>
CDeque<T>::~CDeque()
{
 CNode<T>* ptr = NULL;
 CNode<T>* ptrCur = NULL;
 ptrCur = m_pHead;
 while(ptrCur)
 {
  ptr = ptrCur;
  ptrCur = ptrCur->GetNext();
  delete ptr;
 }
 ptr = NULL;
 m_isize = 0;
 ::DeleteCriticalSection(&critical_sec_object); 
}

template<class T>
bool CDeque<T>::Clear()
{
 CNode<T>* ptr = NULL;
 CNode<T>* ptrCur = NULL;
 ptrCur = m_pHead;
 while(ptrCur)
 {
  ptr = ptrCur;
  ptrCur = ptrCur->GetNext();
  delete ptr;
 }
 ptr = NULL;
 m_isize = 0;
 m_pHead = m_pTail = m_pCurrent = NULL;
 return true;
}

template<class T>
void CDeque<T>::Lock()
{
 /*while(InterlockedExchange(&m_bResourseInUse,TRUE)== TRUE)
 {
  Sleep(1);
 }*/
 //::EnterCriticalSection(&critical_sec_object);
}

template<class T>
void CDeque<T>::UnLock()
{
 /*InterlockedExchange(&m_bResourseInUse,FALSE); */
 //::LeaveCriticalSection(&critical_sec_object);
}

template<class T>
int CDeque<T>::GetSize()
{
 return m_isize;
}

template<class T>
bool CDeque<T>::PushBack(T value)
{
 //thread_space::CStackLock lock(m_criticalObj);
 Lock();
 CNode<T>* ptrCur = NULL;
 if(m_isize == 0)
 {
  CNode<T>* newptr=new CNode<T>(value,NULL,0);
  assert(newptr);
  m_pHead = newptr;
  m_pTail = newptr;
  //m_isize ++;
  InterlockedIncrement(&m_isize);
 }
 else
 {
  CNode<T> * newptr = new CNode<T>(value,NULL,m_isize);
  assert(newptr);
  m_pTail->SetNext(newptr);
  m_pTail = newptr;
  //m_isize ++; 
  InterlockedIncrement(&m_isize);
 } 
 UnLock();
 return true;
}

template<class T>
bool CDeque<T>::PushFront(T value)
{
 Lock();
 CNode<T>* ptrCur = NULL;
 //thread_space::CStackLock lock(m_criticalObj);
 if (m_isize == 0)
 {
  CNode<T> * newptr = new CNode<T>(value,NULL,0);
  assert(newptr);
  m_pHead = newptr;
  m_pTail = newptr;  
 }
 else
 {
  ptrCur = m_pHead;
  while(ptrCur)
  {
   ptrCur->SetIndex(ptrCur->GetIndex()+1);
   ptrCur = ptrCur->GetNext();
  }
  CNode<T> * newptr = new CNode<T>(value,NULL,0);
  newptr->SetNext(m_pHead);
  m_pHead = newptr;
 } 
 //m_isize ++;
 InterlockedIncrement(&m_isize);
 UnLock();
 return true;
}

template<class T>
T CDeque<T>::PopBack()
{
 Lock();
 CNode<T> * ptr = NULL;
 CNode<T>* ptrCur = NULL;
 T v;
 //thread_space::CStackLock lock(m_criticalObj);
 if (m_isize == 1)
 {
  ptr = m_pHead;  
  v = m_pHead->GetNode();
  delete ptr;
  ptr = NULL;
  m_pHead = m_pTail = NULL;
  m_isize = 0;
 }
 else
 {
  ptrCur = m_pHead;
  while (ptrCur)
  {
   ptr = ptrCur->GetNext();
   if (ptr->GetIndex() == m_isize -1 )
   {
    v = m_pTail->GetNode();
    m_pTail = ptrCur;
    ptrCur->SetNext(NULL);
    delete ptr;
    ptr = NULL;
    //m_isize --;
    InterlockedDecrement(&m_isize);
    break;
   }
   ptrCur = ptrCur->GetNext();
  }
 }
 UnLock();
 return v;
}

template<class T>
T CDeque<T>::PopFront()
{
 Lock();
 CNode<T> * ptr = NULL;
 CNode<T>* ptrCur = NULL;
 T v;
 //thread_space::CStackLock lock(m_criticalObj);
 if (m_isize == 1)
 {
  ptr = m_pHead;  
  v = m_pHead->GetNode();
  delete ptr;
  ptr = NULL;
  m_pHead = m_pTail = NULL;
  m_isize = 0;
 }
 else
 {
  ptr = m_pHead;
  v = m_pHead->GetNode();
  m_pHead = m_pHead->GetNext();
  delete ptr;
  ptr = NULL;
  ptrCur = m_pHead;
  while (ptrCur)
  {
   ptrCur->SetIndex(ptrCur->GetIndex()-1);
   ptrCur = ptrCur->GetNext();
  }
  //m_isize --;
  InterlockedDecrement(&m_isize);
 }
 UnLock();
 return v;
}

template<class T>
T CDeque<T>::GetAt(int idx)
{
 Lock();
 assert(idx < m_isize && idx >= 0);
 CNode<T>* ptrCur = NULL;
 ptrCur = m_pHead;
 T v;
 while(ptrCur)
 {
  if (ptrCur->GetIndex() == idx)
  {
   v = ptrCur->GetNode();
   break;
  }
  ptrCur = ptrCur->GetNext();
 }
 UnLock();
 return v;
}

template<class T>
bool CDeque<T>::SetAt(int idx,T value)
{
 Lock();
 CNode<T>* ptrCur = NULL;
 bool bRet = false;
 ptrCur = m_pHead;
 while(ptrCur)
 {
  if (ptrCur->GetIndex() == idx)
  {
   ptrCur->SetNode(value);
   bRet = true;
  }
  ptrCur = ptrCur->GetNext();
 }
 UnLock();
 return bRet;
}

template<class T>
bool CDeque<T>::InsertAt(int idx,T value)
{
 Lock();
 CNode<T>* ptrCur = NULL;
 bool bRet = false;
 //thread_space::CStackLock lock(m_criticalObj);
 if(idx == 0)
 {
  if (m_isize == 0)
  {
   CNode<T>* newptr=new CNode<T>(value,NULL,0);
   assert(newptr);
   m_pHead = newptr;
   m_pTail = newptr;
   //m_isize ++;
   InterlockedIncrement(&m_isize);
  }  
  else
  {
   ptrCur = m_pHead;
   while (ptrCur)
   {
    ptrCur->SetIndex(ptrCur->GetIndex()+1);
    ptrCur = ptrCur->GetNext();
   }
   CNode<T>* newptr=new CNode<T>(value,NULL,0);
   assert(newptr);
   newptr->SetNext(m_pHead);
   m_pHead = newptr;
   //m_isize ++;
   InterlockedIncrement(&m_isize);
  }
  bRet = true;
 }
 else if(idx>0 && idx<m_isize)
 {
  CNode<T> * newptr = new CNode<T>(value,NULL,idx);
  CNode<T> * ptr = NULL;
  ptrCur = m_pHead;
  while(ptrCur)
  {
   ptr = ptrCur->GetNext();
   if (ptr->GetIndex() == idx)
   {    
    newptr->SetNext(ptrCur->GetNext());
    ptrCur->SetNext(newptr);
    //m_isize ++;
    InterlockedIncrement(&m_isize);
    break;
   }
   ptrCur = ptr;
  }
  ptrCur = newptr->GetNext();
  while(ptrCur)
  {
   ptrCur->SetIndex(ptrCur->GetIndex()+1);
   ptrCur = ptrCur->GetNext();
  }
  bRet = true;
 }
 else if (idx == m_isize)
 {
  CNode<T> * newptr = new CNode<T>(value,NULL,idx);
  assert(newptr);
  m_pTail->SetNext(newptr);
  m_pTail = newptr;
  //m_isize ++;
  InterlockedIncrement(&m_isize);
  bRet = true;
 }
 UnLock();
 return bRet;
}
template<class T>
bool CDeque<T>::Erase(int idxBegin)
{
 Lock();
 if (idxBegin >= m_isize || idxBegin<0)
 {
  return false;
 }
 
  //thread_space::CStackLock lock(m_criticalObj);
 CNode<T>* pCur = NULL;
 CNode<T>* pTmp = NULL;
 bool bDelFlag = false;
 if (idxBegin == 0)
 {
  return Clear();
 }
 else //if(idxBegin>0 && idxBegin < m_isize -1)
 {
  pCur = m_pHead;
  while(pCur)
  {
   pTmp = pCur->GetNext();
   if (pTmp->GetIndex() == idxBegin)
   {
    bDelFlag = true;
    break;
   }
   pCur = pCur->GetNext();
  }
  if (bDelFlag)
  {
   m_pTail = pCur;
   pTmp = pCur->GetNext();
   pCur->SetNext(NULL);
   CNode<T> *ptr = NULL;
   while(pTmp)
   {    
    ptr = pTmp;
    pTmp = pTmp->GetNext();
    delete ptr;  
    //m_isize --;
    InterlockedDecrement(&m_isize);
   }
  }
 }   
 /*else if (idxBegin == m_isize -1)
 {
  PopBack();
 }*/
 UnLock();
 return true;
}

template<class T>
bool CDeque<T>::DeleteAt(int idx)
{
 Lock();
 if(idx<0 ||idx >= m_isize)return false;
 CNode<T>* ptrCur = NULL;
 //thread_space::CStackLock lock(m_criticalObj);

 CNode<T> * ptr = NULL;
 CNode<T> * ptrTmp = NULL;
 if (idx == 0)
 {
  if (m_isize == 0)
  {
   ptr = m_pHead;
   m_pHead = m_pTail = m_pCurrent = NULL;
   delete ptr;
   ptr = NULL;
  }
  else
  {
   ptr = m_pHead;
   m_pHead  = m_pHead->GetNext();
   delete ptr;
   if (1 == m_isize)
   {
    m_pTail = m_pHead;
   }
   ptr = NULL;
   ptrCur = m_pHead;
   while(ptrCur)
   {
    ptrCur->SetIndex(ptrCur->GetIndex()-1);
    ptrCur = ptrCur->GetNext();
   }
  }  
  //m_isize --;
  InterlockedDecrement(&m_isize);
 }
 else if(idx>0 && idx<m_isize)
 {
  ptrCur = m_pHead;
  while(ptrCur)
  {
   ptr = ptrCur->GetNext();
   if (ptr->GetIndex() == idx)
   {    
    ptrTmp = ptr;
    ptrCur->SetNext(ptrCur->GetNext()->GetNext());   
    delete ptrTmp;
    ptrTmp = NULL;
    //m_isize --;
    InterlockedDecrement(&m_isize);
    break;
   }
   ptrCur = ptrCur->GetNext();
  }
  while(ptrCur->GetNext())
  {
   ptr = ptrCur->GetNext();
   ptr->SetIndex(ptr->GetIndex()-1);
   ptrCur = ptrCur->GetNext();
  }
  m_pTail = ptrCur;
 }
 UnLock();
 return true;
}


template<class T>
CList<T>::CList()
{
 m_pHead = NULL;
 m_pTail =NULL;
 m_pCurrent = NULL;
 m_isize = 0;
 m_bResourseInUse = FALSE;
}

template<class T>
void CList<T>::Lock()
{
 while(InterlockedExchange(&m_bResourseInUse,TRUE)== TRUE)
 {
   Sleep(1);
 }
}

template<class T>
void CList<T>::UnLock()
{
 InterlockedExchange(&m_bResourseInUse,FALSE); 
}

template<class T>
CList<T>::~CList()
{
 CNode<T>* ptr = NULL;
 CNode<T>* ptrCur = NULL;
 ptrCur = m_pHead;
 while(ptrCur)
 {
  ptr = ptrCur;
  ptrCur = ptrCur->GetNext();
  delete ptr;
 }
 ptr = NULL;
 m_isize = 0;
}

template<class T>
int CList<T>::GetSize()
{
 return m_isize;
}

template<class T>
T CList<T>::GetAt(int idx)
{
 Lock();
 assert(idx < m_isize && idx >= 0);
 CNode<T>* ptrCur = NULL;
 ptrCur = m_pHead;
 while(ptrCur)
 {
  if (ptrCur->GetIndex() == idx)
  {
   return ptrCur->GetNode();
  }
  ptrCur = ptrCur->GetNext();
 }
 UnLock();
}     

template<class T>
bool CList<T>::InsertAt(int idx,T value)
{
 Lock();
 CNode<T>* ptrCur = NULL;
 bool bRet = false;
 //thread_space::CStackLock lock(m_criticalObj);
 if(idx == 0)
 {
  if (m_isize == 0)
  {
   CNode<T>* newptr=new CNode<T>(value,NULL,0);
   assert(newptr);
   m_pHead = newptr;
   m_pTail = newptr;
   //m_isize ++;
   InterlockedIncrement(&m_isize);
  }  
  else
  {
   ptrCur = m_pHead;
   while (ptrCur)
   {
    ptrCur->SetIndex(ptrCur->GetIndex()+1);
    ptrCur = ptrCur->GetNext();
   }
   CNode<T>* newptr=new CNode<T>(value,NULL,0);
   assert(newptr);
   newptr->SetNext(m_pHead);
   m_pHead = newptr;
   //m_isize ++;
   InterlockedIncrement(&m_isize);
  }
  bRet = true;
 }
 else if(idx>0 && idx<m_isize)
 {
  CNode<T> * newptr = new CNode<T>(value,NULL,idx);
  CNode<T> * ptr = NULL;
  ptrCur = m_pHead;
  while(ptrCur)
  {
   ptr = ptrCur->GetNext();
   if (ptr->GetIndex() == idx)
   {    
    newptr->SetNext(ptrCur->GetNext());
    ptrCur->SetNext(newptr);
    //m_isize ++;
    InterlockedIncrement(&m_isize);
    break;
   }
   ptrCur = ptr;
  }
  ptrCur = newptr->GetNext();
  while(ptrCur)
  {
   ptrCur->SetIndex(ptrCur->GetIndex()+1);
   ptrCur = ptrCur->GetNext();
  }
  bRet = true;
 }
 else if (idx == m_isize)
 {
  CNode<T> * newptr = new CNode<T>(value,NULL,idx);
  assert(newptr);
  m_pTail->SetNext(newptr);
  m_pTail = newptr;
  //m_isize ++;
  InterlockedIncrement(&m_isize);
  bRet = true;
 }
 UnLock();
 return bRet;
}

template<class T>
bool CList<T>::DeleteAt(int idx)
{
 Lock();
 if(idx<0 ||idx >= m_isize)return false;
 CNode<T>* ptrCur = NULL;
 //thread_space::CStackLock lock(m_criticalObj);
 CNode<T> * ptr = NULL;
 CNode<T> * ptrTmp = NULL;
 if (idx == 0)
 {
  if (m_isize == 0)
  {
   ptr = m_pHead;
   m_pHead = m_pTail = m_pCurrent = NULL;
   delete ptr;
   ptr = NULL;
  }
  else
  {
   ptr = m_pHead;
   m_pHead  = m_pHead->GetNext();
   delete ptr;
   if (1 == m_isize)
   {
    m_pTail = m_pHead;
   }
   ptr = NULL;
   ptrCur = m_pHead;
   while(ptrCur)
   {
    ptrCur->SetIndex(ptrCur->GetIndex()-1);
    ptrCur = ptrCur->GetNext();
   }
  }  
  //m_isize --;
  InterlockedDecrement(&m_isize);
 }
 else if(idx>0 && idx<m_isize)
 {
  ptrCur = m_pHead;
  while(ptrCur)
  {
   ptr = ptrCur->GetNext();
   if (ptr->GetIndex() == idx)
   {    
    ptrTmp = ptr;
    ptrCur->SetNext(ptrCur->GetNext()->GetNext());   
    delete ptrTmp;
    ptrTmp = NULL;
    //m_isize --;
    InterlockedDecrement(&m_isize);
    break;
   }
   ptrCur = ptrCur->GetNext();
  }
  while(ptrCur->GetNext())
  {
   ptr = ptrCur->GetNext();
   ptr->SetIndex(ptr->GetIndex()-1);
   ptrCur = ptrCur->GetNext();
  }
  m_pTail = ptrCur;
 }
 UnLock();
 return true;
}

template<class T>
bool CList<T>::Clear()
{
 Lock();
 //thread_space::CStackLock lock(m_criticalObj);
 CNode<T>* ptr = NULL;
 CNode<T>* ptrCur = NULL;
 ptrCur = m_pHead;
 while(ptrCur)
 {
  ptr = ptrCur;
  ptrCur = ptrCur->GetNext();
  delete ptr;
 }
 ptr = NULL;
 m_isize = 0;
 m_pHead = m_pTail = m_pCurrent = NULL;
 UnLock();
 return true;
}

template<class T>
bool CList<T>::SetAt(int idx,T value)
{
 Lock();
 CNode<T>* ptrCur = NULL;
 bool bRet = false;
 ptrCur = m_pHead;
 while(ptrCur)
 {
  if (ptrCur->GetIndex() == idx)
  {
   ptrCur->SetNode(value);
   bRet = true;
  }
  ptrCur = ptrCur->GetNext();
 }
 UnLock();
 return bRet;
}
template<class T>
bool CList<T>::Erase(int idxBegin)
{
 Lock();
 if (idxBegin >= m_isize || idxBegin<0)
 {
  return false;
 }
 //thread_space::CStackLock lock(m_criticalObj);
 CNode<T>* pCur = NULL;
 CNode<T>* pTmp = NULL;
 bool bDelFlag = false;
 if (idxBegin == 0)
 {
  return Clear();
 }
 else //if(idxBegin>0 && idxBegin < m_isize -1)
 {
  pCur = m_pHead;
  while(pCur)
  {
   pTmp = pCur->GetNext();
   if (pTmp->GetIndex() == idxBegin)
   {
    bDelFlag = true;
    break;
   }
   pCur = pCur->GetNext();
  }
  if (bDelFlag)
  {
   m_pTail = pCur;
   pTmp = pCur->GetNext();
   pCur->SetNext(NULL);
   CNode<T> *ptr = NULL;
   while(pTmp)
   {    
    ptr = pTmp;
    pTmp = pTmp->GetNext();
    delete ptr;  
    //m_isize --;
    InterlockedDecrement(&m_isize);
   }
  }
 }  
 UnLock();
 return true;
}
}
#endif
//

 

由于时间有限,而且侧重点不一样(目的是想解决多线程的安全问题)

所以,没有自己写迭代器.以后有时间会加上去.当然迭代器本身是STL的一个很重要的功能,但是作者认为,

迭代器本身的目的是为了更好的去使用STL容器.而本文解决的目的不一样.

 

作者:gavin  葛            版权所有                          ( 如若转载,请标明原始地址       谢谢.)

geshanvictor
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
带你深入理解STL之Deque容器
ZeeCoder
08-26 1万+
在介绍STL的deque的容器之前，我们先来总结一下vector和list的优缺点。vector在内存中是分配一段连续的内存空间进行存储，其迭代器采用原生指针即可，因此其支持随机访问和存储，支持下标操作符，节省空间。但是其在分配的内存不够的情况下，需要对容器整体进行重新分配、拷贝和释放等操作，而且在vector中间插入或删除元素效率很低。而list是以节点形式来存放数据，使用的是非连续的内存空间来存
C++11之STL多线程
Ezio
04-25 2937
STL库跨平台； VS2010不支持std::thread库，至少VS2012/2013及其以上可以； 一、库概要 （1）std::thread成员函数 thread(fun, args...); //构造函数，传入函数，后面跟参数，若是类普通成员，需要加this指针作为参数1 void swap(thread& other); //线程交换 bool joinable() const...
STL与多线程+写时拷贝
pi9nc的专栏
01-27 1345
STL与多线程+写时拷贝 分类： Linux多线程编程2013-10-27 20:40 184人阅读 评论(0) 收藏 举报 STL与多线程        STL并不是线程安全的，当多个线程同时读取STL时没什么问题。当多个线程中有写STL时则非线程安全，导致其它线程的end()检测或迭代器算术操作无意义，修改操作可能导致STL重新分配内存，原来的迭代器可能失效。要实
解决多线程安全问题的方法
qq_44272797的博客
11-11 193
java 解决多线程安全问题的方法 synchronized 代码块 synchronized 方法 Lock 锁 synchronized 代码块 格式 synchronized （）{ } 方法实现如下： public class SynchronizedDemo { public static void main(String[] args){ RunnableImpl runnable = new RunnableImpl(); //开启三个新线程
STL 线程安全性
blade2001的专栏
03-27 5237
STL 线程安全性SGI STL [http://www.sgi.com/tech/stl/thread_safety.html]The   SGI   implementation   of   STL   is   thread-safe   only   in   the   sense   that   simultaneous   accesses   to   distinct  
基于C++的线程安全容器。.zip
最新发布
04-30
在C++11及其后续标准中，STL（Standard Template Library）引入了`std::mutex`和`std::lock_guard`等工具，使得开发者能够更容易地实现线程安全的数据结构。例如，一个线程安全的栈可能包含以下关键元素： 1. **...
STL.rar_stl queue
09-21
例如，多线程编程中，可以使用队列来传递任务，一个线程负责生产任务，放入队列，另一个线程从队列中取出任务执行。 总结来说，STL为C++程序员提供了丰富的数据结构和算法，使得代码更加简洁、高效。`queue`作为...
vs2008写的c++程序：多线程串口收发信息编程
04-14
在本项目"vs2008写的c++程序：多线程串口收发信息编程"中，开发者利用Microsoft Visual Studio 2008（VS2008）这个集成开发环境（IDE）编写了一个C++程序，该程序实现了多线程技术来处理串口通信，允许同时进行数据...
操作系统设计 多线程同步模拟（C++版）
02-23
在C++中实现多线程，可以使用STL（Standard Template Library）中的`<thread>`库，或者在Windows环境下，使用如`CreateThread`等API函数，配合MFC框架来创建和管理线程。 **MFC** 是微软开发的一个C++类库，它封装...
STL之三：deque用法详解
热门推荐
longshengguoji的专栏
01-19 7万+
deque函数： deque容器为一个给定类型的元素进行线性处理，像向量一样，它能够快速地随机访问任一个元素，并且能够高效地插入和删除容器的尾部元素。但它又与vector不同，deque支持高效插入和删除容器的头部元素，因此也叫做双端队列。deque类常用的函数如下。 (1)    构造函数 deque():创建一个空deque deque(int nSize):创建一个deque,元素个
STL list在多线程下使用需要注意的问题
lujin0312的专栏
09-01 2345
STL list在多线程下使用需要注意的问题
多线程中使用stl容器
wuyapu的专栏
01-16 1929
在实际中，有时候要在多线程中使用一些stl容器，为了保证安全，需要不断的加锁，解锁下面我实现了一个类自动完成这些操作，感觉比较方便，特贴出来共享 /**************************************************** * 线程安全的容器类 * 可以为所有的容器提供临界区支持 * 使其成为线程安全的 * 如 CSafeContainer >  p; *
自己动手实现简易STL
weixin_44344205的博客
04-15 1950
自己动手实现简易STLSTL六个组件迭代器 & 算法容器，迭代器部分适配器仿函数额外的工作小结 之前学习C++看侯老师的书的时候实现了一下STL的基本组件，包括了6个组件,allocator, iterator, container, trait, functor, algorithm的组件，也是终于搞清楚了6个组件之间的相互关联，但是这么写着(CTRL C + V)有点无聊，于是做了一些数据结构的可视化，当时本来是想加更多的功能来着，比如高亮最近改变或者查找的某个数据。 STL六个组件 比较难理解
STL的多线程安全问题
mercy_ps的博客
08-15 1456
多个线程可以同时读取一个容器中的内容，eg: find, begin, end 等. 多个线程对不同容器的同时写入合法。 但是，多个线程同时读写一个容器是很危险的。以map为例： 当你调用map的任何接口时，比如 end(), begin(), find()等时，可能会返回一个iterator，如果有别的线程正在修改这个map，你的iterator就变得无效了，再用这个iterator行为就...
STL线程安全讨论
冷山不生云
11-21 1678
最近在回头看STL里面的实现，也在进一步研究高性能服务器编程方面的东西，就想到那STL在多线程情况下是否安全呢？ 记录 STL是数据结构和算法的精妙实现，因此为了追求极致的效率，内部并没有给所有的操作加锁。对于STL的容器而言，只有下面这两种情况可以保证线程安全： 多个线程同时读取同一个容器的内容 多个线程同时写不同的容器 其他的情况，比方说：多个线程同时读、写同一个容器。这就不是线程安全...
stl容器是线程安全
03-28
需要注意的是，使用线程安全的STL容器并不能完全解决多线程编程中的所有并发问题，仍然需要合理地设计和管理线程间的同步与通信。此外，使用锁或其他同步机制可能会引入额外的开销和复杂性，需要权衡使用的场景和...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值