UDT源码剖析（四）：UDT的GC线程相关过程代码注释

着UDT::Startup()的启动，GC线程也随之运行了。
GC主要关注的就是UDTSocket的释放，下面我们来看看这个GC线程是怎么实现的。

 查看源代码  
 打印帮助
#ifndef WIN32
 
   void* CUDTUnited::garbageCollect(void* p)
 
#else
 
   DWORD WINAPI CUDTUnited::garbageCollect(LPVOID p)
 
#endif
 
{
 
   // 获得当前GC对应的Socket单位
 
   CUDTUnited* self = (CUDTUnited*)p;
 
 
 
   // 应用锁保护，这里的锁是CUDTUnited::m_GCStopLock
 
   CGuard gcguard(self->m_GCStopLock);
 
 
 
   // 如果Socket单位没有标记为关闭中，那么GC持续生效
 
   while (!self->m_bClosing)
 
   {
 
      self->checkBrokenSockets();
 
 
 
      #ifdef WIN32
 
         self->checkTLSValue();
 
      #endif
 
 
 
      // 这里处理超时解锁，windows下的WaitForSingleObject函数直接输入超时时间间隔
 
      // 而非windows的需要提供绝对时间，所以需要先根据当前时间得到超时时间，然后作为参数传入pthread_cond_timedwait
 
      // 实际上就是当计时器用，确保两次检查的时间间隔最多为1秒钟
 
      #ifndef WIN32
 
         timeval now;
 
         timespec timeout;
 
         gettimeofday(&now, 0);
 
         timeout.tv_sec = now.tv_sec + 1;
 
         timeout.tv_nsec = now.tv_usec * 1000;
 
 
 
         pthread_cond_timedwait(&self->m_GCStopCond, &self->m_GCStopLock, &timeout);
 
      #else
 
         WaitForSingleObject(self->m_GCStopCond, 1000);
 
      #endif
 
   }
 
 
 
   // 到这里说明Socket单位处于正在关闭的状态
 
 
 
   // remove all sockets and multiplexers
 
   // 移除所有的Sockets和多路复用器
 
 
 
   // 启动锁保护，这里不直接用CGuard是因为要多次用到这个锁，并且在下面的checkBrokenSockets中也要使用该锁，所以手动处理
 
   CGuard::enterCS(self->m_ControlLock);
 
   for (map<UDTSOCKET, CUDTSocket*>::iterator i = self->m_Sockets.begin(); i != self->m_Sockets.end(); ++ i)
 
   {
 
      // 标记作废，调用关闭，并标记为CLOSED，更新时间戳，将Socket对象加入已关闭列表
 
      i->second->m_pUDT->m_bBroken = true;
 
      i->second->m_pUDT->close();
 
      i->second->m_Status = CLOSED;
 
      i->second->m_TimeStamp = CTimer::getTime();
 
      self->m_ClosedSockets[i->first] = i->second;
 
 
 
      // remove from listener's queue
 
      // 从监听列表中移除
 
      map<UDTSOCKET, CUDTSocket*>::iterator ls = self->m_Sockets.find(i->second->m_ListenSocket);
 
      if (ls == self->m_Sockets.end())
 
      {
 
          // 如果在Socket列表和已关闭列表中都未找到监听Socket，则不作处理
 
         ls = self->m_ClosedSockets.find(i->second->m_ListenSocket);
 
         if (ls == self->m_ClosedSockets.end())
 
            continue;
 
      }
 
 
 
      // 运行到这里说明找到了监听Socket
 
      // 从监听Socket的待Accept及已Accept列表中移除当前Socket
 
      CGuard::enterCS(ls->second->m_AcceptLock);
 
      ls->second->m_pQueuedSockets->erase(i->second->m_SocketID);
 
      ls->second->m_pAcceptSockets->erase(i->second->m_SocketID);
 
      CGuard::leaveCS(ls->second->m_AcceptLock);
 
   }
 
   // 已移除所有Socket项目，清空列表
 
   self->m_Sockets.clear();
 
 
 
   // 将已关闭列表中的所有项时间戳标记为0
 
   for (map<UDTSOCKET, CUDTSocket*>::iterator j = self->m_ClosedSockets.begin(); j != self->m_ClosedSockets.end(); ++ j)
 
   {
 
      j->second->m_TimeStamp = 0;
 
   }
 
 
 
   // 手动解锁
 
   CGuard::leaveCS(self->m_ControlLock);
 
 
 
   while (true)
 
   {
 
      // 检查作废Socket，直到已关闭Socket列表为空
 
      self->checkBrokenSockets();
 
 
 
      CGuard::enterCS(self->m_ControlLock);
 
      bool empty = self->m_ClosedSockets.empty();
 
      CGuard::leaveCS(self->m_ControlLock);
 
 
 
      if (empty)
 
         break;
 
 
 
      CTimer::sleep();
 
   }
 
 
 
   #ifndef WIN32
 
      return NULL;
 
   #else
 
      return 0;
 
   #endif
 
}

void CUDTUnited::checkBrokenSockets()
 
{
 
   CGuard cg(m_ControlLock);
 
 
 
   // set of sockets To Be Closed and To Be Removed
 
   // tbc要关闭的Socket列表
 
   // tbr要移除的Socket列表
 
   vector<UDTSOCKET> tbc;
 
   vector<UDTSOCKET> tbr;
 
 
 
   // 循环单元中所有Socket
 
   for (map<UDTSOCKET, CUDTSocket*>::iterator i = m_Sockets.begin(); i != m_Sockets.end(); ++ i)
 
   {
 
      // check broken connection
 
      // 检查状态是否为已作废
 
      if (i->second->m_pUDT->m_bBroken)
 
      {
 
         if (i->second->m_Status == LISTENING)
 
         {
 
            // for a listening socket, it should wait an extra 3 seconds in case a client is connecting
 
            // 如果该Socket是一个监听Socket，那么需要在作废后3秒钟再处理该Socket，因为可能有客户端正在连接
 
            if (CTimer::getTime() - i->second->m_TimeStamp < 3000000)
 
               continue;
 
         }
 
         else if ((i->second->m_pUDT->m_pRcvBuffer->getRcvDataSize() > 0) && (i->second->m_pUDT->m_iBrokenCounter -- > 0))
 
         {
 
            // if there is still data in the receiver buffer, wait longer
 
            // 如果接收缓存中还有数据，并且检查计数大于0，则暂不处理
 
            // 检查计数m_iBrokenCounter，在通常情况下为30，调用shutdown时为60，可以理解为30秒、60秒
 
            continue;
 
         }
 
 
 
         //close broken connections and start removal timer
 
         // 关闭作废的连接，并移除计时器
 
         // 标记状态为CLOSED，更新时间戳为当前，将Socket加入要关闭的Socket列表
 
         i->second->m_Status = CLOSED;
 
         i->second->m_TimeStamp = CTimer::getTime();
 
         tbc.push_back(i->first);
 
         m_ClosedSockets[i->first] = i->second;
 
 
 
         // remove from listener's queue
 
         // 从监听列表中移除
 
         map<UDTSOCKET, CUDTSocket*>::iterator ls = m_Sockets.find(i->second->m_ListenSocket);
 
         if (ls == m_Sockets.end())
 
         {
 
             // 如果在Socket列表和已关闭列表中都未找到监听Socket，则不作处理
 
            ls = m_ClosedSockets.find(i->second->m_ListenSocket);
 
            if (ls == m_ClosedSockets.end())
 
               continue;
 
         }
 
 
 
         // 运行到这里说明找到了监听Socket
 
         // 从监听Socket的待Accept及已Accept列表中移除当前Socket
 
         CGuard::enterCS(ls->second->m_AcceptLock);
 
         ls->second->m_pQueuedSockets->erase(i->second->m_SocketID);
 
         ls->second->m_pAcceptSockets->erase(i->second->m_SocketID);
 
         CGuard::leaveCS(ls->second->m_AcceptLock);
 
      }
 
   }
 
 
 
   // 遍历已关闭Socket列表中的项
 
   for (map<UDTSOCKET, CUDTSocket*>::iterator j = m_ClosedSockets.begin(); j != m_ClosedSockets.end(); ++ j)
 
   {
 
      // 有犹豫时间
 
      if (j->second->m_pUDT->m_ullLingerExpiration > 0)
 
      {
 
         // asynchronous close:
 
         // 异步关闭
 
         // 关闭条件为：发送列表已经为空，或者发送列表的当前缓存大小为0，或者超出犹豫时间
 
         if ((NULL == j->second->m_pUDT->m_pSndBuffer) || (0 == j->second->m_pUDT->m_pSndBuffer->getCurrBufSize()) || (j->second->m_pUDT->m_ullLingerExpiration <= CTimer::getTime()))
 
         {
 
            j->second->m_pUDT->m_ullLingerExpiration = 0;
 
            j->second->m_pUDT->m_bClosing = true;
 
            j->second->m_TimeStamp = CTimer::getTime();
 
         }
 
      }
 
 
 
      // timeout 1 second to destroy a socket AND it has been removed from RcvUList
 
      // Socket被标记时间戳后1秒钟，并且已经从接收列表节点中移除，那么把它放入可移除列表
 
      if ((CTimer::getTime() - j->second->m_TimeStamp > 1000000) && ((NULL == j->second->m_pUDT->m_pRNode) || !j->second->m_pUDT->m_pRNode->m_bOnList))
 
      {
 
         tbr.push_back(j->first);
 
      }
 
   }
 
 
 
   // move closed sockets to the ClosedSockets structure
 
   // 将tbc可关闭Socket列表中的对象从当前Socket列表中移除，这里作者的注释有问题
 
   // 实际上在上面m_ClosedSockets[i->first] = i->second;已经把这些Socket添加到ClosedSockets中了
 
   for (vector<UDTSOCKET>::iterator k = tbc.begin(); k != tbc.end(); ++ k)
 
      m_Sockets.erase(*k);
 
 
 
   // remove those timeout sockets
 
   // 对tbr可移除Socket列表中的项执行removeSocket
 
   for (vector<UDTSOCKET>::iterator l = tbr.begin(); l != tbr.end(); ++ l)
 
      removeSocket(*l);
 
}

void CUDTUnited::removeSocket(const UDTSOCKET u)
 
{
 
   // 可移除的Socket必须在m_ClosedSockets列表中存在
 
   map<UDTSOCKET, CUDTSocket*>::iterator i = m_ClosedSockets.find(u);
 
 
 
   // invalid socket ID
 
   // 如果不存在则不予移除
 
   if (i == m_ClosedSockets.end())
 
      return;
 
 
 
   // decrease multiplexer reference count, and remove it if necessary
 
   // 获取复用器ID
 
   const int mid = i->second->m_iMuxID;
 
 
 
   // 如果待Accept队列不为空
 
   if (NULL != i->second->m_pQueuedSockets)
 
   {
 
      CGuard::enterCS(i->second->m_AcceptLock);
 
 
 
      // if it is a listener, close all un-accepted sockets in its queue and remove them later
 
      // 如果当前Socket是一个监听Socket，就要关闭所有尚未Accept的连接并在稍后将它们移除
 
      for (set<UDTSOCKET>::iterator q = i->second->m_pQueuedSockets->begin(); q != i->second->m_pQueuedSockets->end(); ++ q)
 
      {
 
         m_Sockets[*q]->m_pUDT->m_bBroken = true;
 
         m_Sockets[*q]->m_pUDT->close();
 
         m_Sockets[*q]->m_TimeStamp = CTimer::getTime();
 
         m_Sockets[*q]->m_Status = CLOSED;
 
         m_ClosedSockets[*q] = m_Sockets[*q];
 
         m_Sockets.erase(*q);
 
      }
 
 
 
      CGuard::leaveCS(i->second->m_AcceptLock);
 
   }
 
 
 
   // remove from peer rec
 
   // 从m_PeerRec中移除该Socket信息
 
   // m_PeerRec用来记录连接节点信息以防止重复的连接请求，必须在关闭时移除以保证下次连接不会被拒绝
 
   map<int64_t, set<UDTSOCKET> >::iterator j = m_PeerRec.find((i->second->m_PeerID << 30) + i->second->m_iISN);
 
   if (j != m_PeerRec.end())
 
   {
 
      j->second.erase(u);
 
      if (j->second.empty())
 
         m_PeerRec.erase(j);
 
   }
 
 
 
   // delete this one
 
   // 关闭、删除当前Socket对象，并从m_ClosedSockets列表中移除
 
   i->second->m_pUDT->close();
 
   delete i->second;
 
   m_ClosedSockets.erase(i);
 
 
 
   // 从复用器列表中查找当前的复用器
 
   map<int, CMultiplexer>::iterator m;
 
   m = m_mMultiplexer.find(mid);
 
   if (m == m_mMultiplexer.end())
 
   {
 
      //something is wrong!!!
 
      // 如果没找到肯定有什么地方搞错了，但是这里没做处理
 
      return;
 
   }
 
 
 
   // 把当前复用器所对应的UDT计数减一
 
   // 如果减至0，说明已经没有可复用的UDT对象，则从复用器列表中将当前复用器移除
 
   m->second.m_iRefCount --;
 
   if (0 == m->second.m_iRefCount)
 
   {
 
      m->second.m_pChannel->close();
 
      delete m->second.m_pSndQueue;
 
      delete m->second.m_pRcvQueue;
 
      delete m->second.m_pTimer;
 
      delete m->second.m_pChannel;
 
      m_mMultiplexer.erase(m);
 
   }
 
}