并行处理之引用计数与状态的使用

最新推荐文章于 2025-10-31 10:44:04 发布
原创 最新推荐文章于 2025-10-31 10:44:04 发布 · 2k 阅读 · 1 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
收录于
源码

当前文章被收录于：

源码
24 篇文章 0 人学习
订阅专栏 查看详情
并行处理

当前文章被收录于：

并行处理
8 篇文章 0 人学习
订阅专栏 查看详情
本文探讨了在并行处理中如何利用引用计数和对象状态来确保多线程操作的有效性和并发性。以远程文件系统客户端连接对象类为例，解释了Open和Close方法如何与状态配合，防止异常并提升并发性能。了解这种并发控制策略对于高并发软件开发至关重要。

--------------------------------------------------------------------------------
标题: 并行处理之引用计数与状态的使用
作者: 叶飞虎
日期: 2013.03.09
--------------------------------------------------------------------------------

    在并行处理过程中多线程对同一对象进行操作，而且操作各自独立，但又需要依赖对象
本身的状态，如已打开或已登录等等。这时需要给状态进行引用计数，以保证操作的有效和
并发性。

    为了便于描述, 以<远程文件系统>中的客户端连接对象类(TRFConnObj)中部分代码做为
示例:

// 对象状态
enum TObjState
        {osInactive        = 0,        // 未打开
         osClosing         = 1,        // 正在关闭
         osOpening         = 2,        // 正在打开
         osOpened          = 3};       // 已经打开

// 引用计数加 1
bool TRFConnObj::IncRefCount()
{
   // 初始化
   bool result = false;

   // 操作
   Lock();
   if (FState == osOpened)
   {
      FRefCount++;
      result = true;
   }
   Unlock();

   // 返回结果
   return result;
}

// 引用计数减 1
void TRFConnObj::DecRefCount()
{
   Lock();
   if (FRefCount > 0)
      FRefCount--;
   Unlock();
}

// 打开
long TRFConnObj::Open()
{
   // 初始化
   long  result   = crStateInvalid;
   bool  boolNext = false;

   // 更改状态
   Lock();
   if (FState == osInactive)
   {
      FState   = osOpening;
      boolNext = true;
      FRefCount= 0;
   }
   else if (FState == osOpened)
      result   = crSuccess;
   Unlock();

   // 判断是否继续
   if (boolNext)
   {
      // 执行打开
      boolNext = false;
      result   = DoOpen();

      // 更改状态
      Lock();
      if (FState != osOpening)
         boolNext = true;
      else if (result == crSuccess)
         FState   = osOpened;
      else
         FState   = osInactive;
      Unlock();

      // 判断是否需要关闭
      if (boolNext)
      {
         // 执行关闭
         if (result == crSuccess)
         {
            DoClose(true);
            result = crFailure;
         }

         // 更改状态(不需要加锁)
         FState = osInactive;
      }
   }

   // 返回结果
   return result;
}

// 关闭
void TRFConnObj::Close(bool ANeedWait)
{
   // 初始化
   bool boolNext  = false;
   bool boolWait  = false;

   // 更改状态
   Lock();
   if (FState == osOpened)
   {
      FState   = osClosing;
      boolNext = true;
   }
   else if (FState == osOpening)
   {
      FState   = osClosing;
      boolWait = true;
   }
   else if (FState == osClosing)
      boolWait = ANeedWait;
   Unlock();

   // 判断是否等待
   if (boolWait)
   {
      // 等待 Close 结束
      while (FState == osClosing)
         Sleep(15);
   }
   else if (boolNext)
   {
      // 执行关闭
      DoClose(true);

      // 更改状态(不需要加锁)
      FState = osInactive;
   }
}

// 并行操作的方法
long TRFConnObj::<method>(...)
{
   // 初始化
   long result = crStateInvalid;

   // 引用计数加 1
   if (IncRefCount())
   {
      // 操作
      // ??? ... ...

      // 引用计数减 1
      DecRefCount();
   }

   // 返回结果
   return result;
}


    可以把 Open 和 Close 方法理解为打开和关闭并行处理之门，只有 Open 之后才有效。
当调用 Close 方法时，若还有其它线程正在操作相关方法，则会等待操作完成后才能关闭，
若已调用 Close 方法且状态为 osClosing 且其它线程开始操作相关方法时，则会直接返回
状态无效，并拒之门外。


    对象状态和引用计数配合使用会提高事件处理的并发性，且不会在边界状态时导致异常
发生，同时还可以保证系统的并发性能。在服务器程序的开发中会常用到引用计数和状态，
若完全理解 Open 和 Close 中状态处理，则有助于灵活运用到并发性高的软件开发中。


<远程文件系统>提供完整源码，下载地址如下:
    远程文件系统服务器源码[http://download.csdn.net/detail/kyee/5109478]
    远程文件系统客户端源码[http://download.csdn.net/detail/kyee/5109484]
    服务器和客户端相关接口[http://download.csdn.net/detail/kyee/5109491]


客户端连接对象类(TRFConnObj)部分代码如下:

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

/* TRFConnObj - 客户端连接对象类 */

class TRFConnObj
{
public:
   TRFConnObj(TRFConnEvent* AEventObj  = NULL, const char* AHost     = NULL,
                      long  APort      = 0,    const char* APassword = NULL);
   virtual ~TRFConnObj();

   // 属性
   void*             Data() const         { return FData; }
   TRCConnection*    ConnObj() const      { return FConnObj; }
   TRFConnEvent*     EventObj() const     { return FEventObj; }
   Longword          CallTimeout() const  { return FCallTimeout; }

   TObjState         State() const        { return FState; }

   KYString          RFVersion() const    { return FRFInfo.Version; }
   TDateTime         RFStartTime() const  { return FRFInfo.StartTime; }
   TDateTime         RFDateTime();

   // 设置属性
   void              SetData(void* AData) { FData = AData; }
   void              SetCallTimeout(Longword ATimeout);

   // 打开/关闭连接
   long              Open();
   void              Close(bool ANeedWait = false);

   // 读取/设置文件属性
   long              GetFileAttr(const char* AFileName, long* Attrib);
   long              SetFileAttr(const char* AFileName, long  Attrib);

   // 文件存在/删除/移动文件或目录
   long              FileExisted(const char* AFileName);
   long              DeleteFile(const char* AFileName);
   long              MoveFile(const char* AOldName, const char* ANewName);

   // 目录存在/创建/删除
   long              DirExisted(const char* APathName);
   long              CreateDir(const char* APathName, bool AForced = false);
   long              RemoveDir(const char* APathName, bool AForced = false);

   // 磁盘操作相关函数
   long              DriveType(const char* ADrive, long* AType);
   long              DiskSpace(const char* APath, __int64* ATotalSpace,
                                                  __int64* AFreeSpace);

protected:
   // 状态锁
   void              Lock() const         { FLock->Enter(); }
   void              Unlock() const       { FLock->Leave(); }

   // 对象次数增减
   long              IncObjTimes()        { return InterlockedIncrement(&FObjTimes); }
   long              DecObjTimes()        { return InterlockedDecrement(&FObjTimes); }

   // 引用计数增减
   bool              IncRefCount_Valid();
   bool              IncRefCount();
   void              DecRefCount();

   // 读取 RF 的信息
   void              GetRFInfo();
   void              GetRFDateTime();

   // 存取 RF 属性方法
   long              GetRFInt(long Attrib, long& AValue);
   long              GetRFStr(long Attrib, KYString& AValue);
   long              SetRFInt(long Attrib, long AValue);
   long              SetRFStr(long Attrib, const char* AValue, long ALen);

private:
   // 执行初始化/释放
   void              DoInit();
   void              DoFreeing()          { FEventObj->DoFreeing(this); }

   // 执行打开/关闭
   long              DoOpen();
   void              DoClose(bool ANeedClose);

   // 执行断开连接
   void              DoDisconnect();
   void              CallOnDisconnect();

   // 执行 RC 事件的回调方法
   void              DoRecvData(const void* AData, long ASize);

private:
   void*             FData;               // 自定义数据
   TKYCritSect*      FLock;               // 状态锁
   TRCConnection*    FConnObj;            // RC 连接对象
   TRFConnEvent*     FEventObj;           // 事件对象

   TObjState         FState;              // 状态
   long              FObjTimes;           // 对象次数
   long              FRefCount;           // 引用计数
   Longword          FCallTimeout;        // 调用超时时长(毫秒)

   TRFInfo           FRFInfo;             // 远程文件服务器信息
   Longword          FLastTick;           // 读取最后一次 RFDateTime 的 tick 值
   TDateTime         FDeltaTime;          // 远程文件服务器的当前时间差值

   TRFCOnDisconnect  FOnDisconnect;       // OnDisconnect 回调事件函数

private:
   // RC 连接的回调函数
   static void __stdcall   _DoRCCallback(long AConnID, long AEvent,
                                         long ACmdID,  long AReturn);
   static void __stdcall   _DoRCRecvData(long AConnID, long ASize, const void* AData);
};


 

// 返回值及错误码
enum TRFCResult
        {crSuccess         =  1,       // 成功
         crFailure         =  0,       // 失败
         crUnknown         = -1,       // 未知错误
         crNotExist        = -2,       // 不存在(如: AConnObj)
         crNotStart        = -3,       // 服务器未启动
         crNotConnect      = -4,       // 连接未打开
         crNonsupport      = -5,       // 不支持
         crVersion         = -6,       // 版本太低
         crPassword        = -7,       // 密码错误
         crIsExisted       = -8,       // 已存在
         crIsIllegal       = -9,       // 不合法
         crAttrInvalid     = -10,      // 属性无效
         crStateInvalid    = -11,      // 状态无效
         crHandleInvalid   = -12,      // 句柄无效
         crAccessIllegal   = -13};     // 存取非法

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

/* TRFConnObj - 客户端连接对象类 */

// ---------------- 静态函数 ----------------
// RC 连接的回调函数
void __stdcall TRFConnObj::_DoRCCallback(long AConnID, long AEvent,
                                         long ACmdID,  long AReturn)
{
   if (AEvent == rcvConnClosed)
      try
      {
         TRCConnection* objConn = ConnID2Object(AConnID);
         if (objConn != NULL)
            ((TRFConnObj*)objConn->Data())->DoDisconnect();
      }
      catch (...) {}
}

// RC 接收自定义数据的回调函数
void __stdcall TRFConnObj::_DoRCRecvData(long AConnID, long  ASize,
                                                 const void* AData)
{
   try
   {
      TRCConnection* objConn = ConnID2Object(AConnID);
      if (objConn != NULL)
         ((TRFConnObj*)objConn->Data())->DoRecvData(AData, ASize);
   }
   catch (...) {}
}

// ---------------- 构造函数和析构函数 ----------------
// 构造函数
TRFConnObj::TRFConnObj(TRFConnEvent* AEventObj, const char* AHost,
                               long  APort,     const char* APassword)
{
   // 初始化
   FData          = NULL;
   FState         = osInactive;
   FEventObj      = AEventObj;
   FObjTimes      = 1;
   FRefCount      = 0;
   FCallTimeout   = Timeout_DefCall;

   // 初始化函数指针
   FOnDisconnect  = NULL;

   // 创建连接对象
   FConnObj       = new TRCConnection(AHost, RF_AppName, APassword, APort,
                                      &TRFConnObj::_DoRCCallback);

   // 设置连接对象属性
   FConnObj->SetData(this);
   FConnObj->SetLinger(0);
   FConnObj->SetOnRecvData(&TRFConnObj::_DoRCRecvData);

   // 创建对象
   FLock          = new TKYCritSect;

   // 执行初始化
   DoInit();
}

// 析构函数
TRFConnObj::~TRFConnObj()
{
   // 关闭
   Close(true);
   FConnObj->SetData(NULL);

   // 执行释放方法
   DoFreeing();

   // 释放对象
   FreeAndNil(FConnObj);
   FreeAndNil(FLock);
}

// ---------------- 私有函数 ----------------
// 执行初始化
void TRFConnObj::DoInit()
{
   // 初始化
   FLastTick            = 0;
   FDeltaTime           = 0.0;

   // 初始化信息
   FRFInfo.StartTime    = 0.0;

   // 清除
   FRFInfo.Version.Clear();
}

// 执行打开
long TRFConnObj::DoOpen()
{
   // 初始化
   long result = crFailure;

   // 打开连接
   switch (RCConnOpen(FConnObj->ConnID()))
   {
   case CRet_Success:
      // 加载命令
      if (FConnObj->LoadCmd())
      {
         // 取 RF 信息
         GetRFInfo();

         // 返回成功
         result = crSuccess;
      }
      else
         FConnObj->Close();

      break;

   case CRet_Failure:            result = crNotConnect;  break;
   case CRet_AppPass_Error:      result = crPassword;    break;
   case CRet_AppName_NotExist:   result = crNotStart;    break;
   case CRet_ConnID_NotExist:    result = crNotExist;    break;
   default:                      result = crUnknown;
   }

   // 返回结果
   return result;
}

// 执行关闭
void TRFConnObj::DoClose(bool ANeedClose)
{
   // 判断是否需要关闭
   if (ANeedClose)
      FConnObj->Close();

   // 等待 RefCount == 0
   while (FRefCount > 0)
      Sleep(15);

   // 执行初始化
   DoInit();
}

// 执行连接的断开事件
void TRFConnObj::DoDisconnect()
{
   // 初始化
   bool boolNext  = false;
   bool boolClose = false;

   // 检查状态
   Lock();
   if (FState >= osOpened)
   {
      boolClose   = true;
      boolNext    = true;
      FState      = osClosing;
   }
   else if (FState == osOpening)
      FState      = osClosing;
   else
      boolNext    = (FState == osClosing);
   Unlock();

   // 判断是否继续
   if (boolNext)
   {
      // 激发 OnDisconnect 事件方法
      FEventObj->DoDisconnect(this);

      // 激发 OnDiconnect 函数指针
      CallOnDisconnect();

      // 判断是否需要关闭
      if (boolClose)
      {
         // 执行关闭
         DoClose(false);

         // 更改状态(不需要加锁)
         FState = osInactive;
      }
   }
}

// 激发 OnDiconnect 函数指针
void TRFConnObj::CallOnDisconnect()
{
   if (FOnDisconnect != NULL)
      __try
      {
         (*FOnDisconnect)(this);
      }
      __except (_ExceptIgnore) {}
}

// 执行 RC 接收自定义数据方法
void TRFConnObj::DoRecvData(const void* AData, long ASize)
{
}

// ---------------- 保护函数 ----------------
// 引用计数加 1
bool TRFConnObj::IncRefCount_Valid()
{
   // 初始化
   bool result = false;

   // 操作
   Lock();
   if (FState >= osOpening)
   {
      FRefCount++;
      result = true;
   }
   Unlock();

   // 返回结果
   return result;
}

// 引用计数加 1
bool TRFConnObj::IncRefCount()
{
   // 初始化
   bool result = false;

   // 操作
   Lock();
   if (FState == osOpened)
   {
      FRefCount++;
      result = true;
   }
   Unlock();

   // 返回结果
   return result;
}

// 引用计数减 1
void TRFConnObj::DecRefCount()
{
   Lock();
   if (FRefCount > 0)
      FRefCount--;
   Unlock();
}

// ---------------- 公有函数 ----------------
// 打开
long TRFConnObj::Open()
{
   // 初始化
   long  result   = crStateInvalid;
   bool  boolNext = false;

   // 更改状态
   Lock();
   if (FState == osInactive)
   {
      FState   = osOpening;
      boolNext = true;
      FRefCount= 0;
   }
   else if (FState == osOpened)
      result   = crSuccess;
   Unlock();

   // 判断是否继续
   if (boolNext)
   {
      // 执行打开
      boolNext = false;
      result   = DoOpen();

      // 更改状态
      Lock();
      if (FState != osOpening)
         boolNext = true;
      else if (result == crSuccess)
         FState   = osOpened;
      else
         FState   = osInactive;
      Unlock();

      // 判断是否需要关闭
      if (boolNext)
      {
         // 执行关闭
         if (result == crSuccess)
         {
            DoClose(true);
            result = crFailure;
         }

         // 更改状态(不需要加锁)
         FState = osInactive;
      }
   }

   // 返回结果
   return result;
}

// 关闭
void TRFConnObj::Close(bool ANeedWait)
{
   // 初始化
   bool boolNext  = false;
   bool boolWait  = false;

   // 更改状态
   Lock();
   if (FState == osOpened)
   {
      FState   = osClosing;
      boolNext = true;
   }
   else if (FState == osOpening)
   {
      FState   = osClosing;
      boolWait = true;
   }
   else if (FState == osClosing)
      boolWait = ANeedWait;
   Unlock();

   // 判断是否等待
   if (boolWait)
   {
      // 等待 Close 结束
      while (FState == osClosing)
         Sleep(15);
   }
   else if (boolNext)
   {
      // 执行关闭
      DoClose(true);

      // 更改状态(不需要加锁)
      FState = osInactive;
   }
}

// 文件存在
long TRFConnObj::FileExisted(const char* AFileName)
{
   // 初始化
   long result = crStateInvalid;

   // 检查参数
   if ((AFileName == NULL) || (*AFileName == '\0'))
      result = crIsIllegal;
   else if (IncRefCount()) // 引用计数加 1
   {
      // 操作
      // ??? ... ...

      // 引用计数减 1
      DecRefCount();
   }

   // 返回结果
   return result;
}

// 文件删除
long TRFConnObj::DeleteFile(const char* AFileName)
{
   // 初始化
   long result = crStateInvalid;

   // 检查参数
   if ((AFileName == NULL) || (*AFileName == '\0'))
      result = crIsIllegal;
   else if (IncRefCount()) // 引用计数加 1
   {
      // 操作
      // ??? ... ...

      // 引用计数减 1
      DecRefCount();
   }

   // 返回结果
   return result;
}

// 移动文件或目录
long TRFConnObj::MoveFile(const char* AOldName, const char* ANewName)
{
   // 初始化
   long result = crStateInvalid;

   // 检查参数
   if ((AOldName == NULL) || (*AOldName == '\0')
                          || (ANewName == NULL) || (*ANewName == '\0'))
      result = crIsIllegal;
   else if (IncRefCount()) // 引用计数加 1
   {
      // 操作
      // ??? ... ...

      // 引用计数减 1
      DecRefCount();
   }

   // 返回结果
   return result;
}

// 目录存在
long TRFConnObj::DirExisted(const char* APathName)
{
   // 初始化
   long result = crStateInvalid;

   // 检查参数
   if ((APathName == NULL) || (*APathName == '\0'))
      result = crIsIllegal;
   else if (IncRefCount()) // 引用计数加 1
   {
      // 操作
      // ??? ... ...

      // 引用计数减 1
      DecRefCount();
   }

   // 返回结果
   return result;
}

// 目录创建
long TRFConnObj::CreateDir(const char* APathName, bool AForced)
{
   // 初始化
   long result = crStateInvalid;

   // 检查参数
   if ((APathName == NULL) || (*APathName == '\0'))
      result = crIsIllegal;
   else if (IncRefCount()) // 引用计数加 1
   {
      // 操作
      // ??? ... ...

      // 引用计数减 1
      DecRefCount();
   }

   // 返回结果
   return result;
}

// 目录删除
long TRFConnObj::RemoveDir(const char* APathName, bool AForced)
{
   // 初始化
   long result = crStateInvalid;

   // 检查参数
   if ((APathName == NULL) || (*APathName == '\0'))
      result = crIsIllegal;
   else if (IncRefCount()) // 引用计数加 1
   {
      // 操作
      // ??? ... ...

      // 引用计数减 1
      DecRefCount();
   }

   // 返回结果
   return result;
}

// 取驱动器类型
long TRFConnObj::DriveType(const char* ADrive, long* AType)
{
   // 初始化
   long result = crStateInvalid;

   // 检查参数
   if ((ADrive == NULL) || (*ADrive == '\0') || (AType == NULL))
      result = crIsIllegal;
   else if (IncRefCount()) // 引用计数加 1
   {
      // 操作
      // ??? ... ...

      // 引用计数减 1
      DecRefCount();
   }

   // 返回结果
   return result;
}

// 取磁盘空闲空间
long TRFConnObj::DiskSpace(const char* APath, __int64* ATotalSpace,
                                              __int64* AFreeSpace)
{
   // 初始化
   long result = crStateInvalid;

   // 检查参数
   if ((APath == NULL) || (*APath == '\0')
                       || ((ATotalSpace == NULL) && (AFreeSpace == NULL)))
      result = crIsIllegal;
   else if (IncRefCount()) // 引用计数加 1
   {
      // 操作
      // ??? ... ...

      // 引用计数减 1
      DecRefCount();
   }

   // 返回结果
   return result;
}


--------------------------------------------------------------------------------

标签
#并行处理 #引用计数 #C++源码
垃圾回收-- 引用计数法
comprel的博客
06-29 1926
引用计数法 引用计数法，最重要的就是计数器，记录有多少引用该对象 引用计数法与mutator 的执行密切相关，在mutator 的处理过程中通过增减计数器的值来进行内存管理， 在分配和更新对象时会发生计数的变化 更新操作过程： 对指针ptr 新引用的对象（obj）的计数器进行增量操作 对指针ptr 之前引用的对象（*ptr）的计数器进行减量操作 update_ptr(ptr, obj){ ...
【C++】智能指针之引用计数的实现
小do在努力
09-11 5137
本文将简单的介绍，C++11中的智能指针的引用计数大致是如何实现的。部分内容节选自 C++ primer 5th。
易语言根据文件句柄取文件路径
07-22
易语言根据文件句柄取文件路径源码,根据文件句柄取文件路径,文件句柄取文件路径名,lopen,ZwQueryObject,WToM,lclose,QueryDosDevice,StrCmpNI
【升级】易语言文件解锁（关闭句柄法）-易语言
06-12
前言 上一次发布过的程序：【首发】检测文件的占用，具有学习和商业价值(By超级用户)，可以使用，仿电脑管家 正文 对于怎么枚举文件句柄 ，上一帖子对此有介绍，核心代码大概如下：如果 (ZwQueryObject (handle, #ObjectTypeInformation, unicode, 0, size) ≠ #STATUS_INVALID_HANDLE )' 只要不是无效的，为什么，详细看下面的注释 ' 参数 ' Handle ' 对象的一个句柄来获取信息。 ' ObjectInformationClass ' 指定一个OBJECT_INFORMATION_CLASS返回值的类型决定了信息在ObjectInformation缓冲区。 ' ObjectInformation ' 一个指向caller-allocated缓冲接收请求的信息。 ' ObjectInformationLength ' 指定的大小,以字节为单位,ObjectInformation缓冲区。 ' ReturnLength ' 一个指向变量的指针,接收的大小,以字节为单位,请求的关键信息。如果NtQueryObject STATUS_SUCCESS返回,返回的变量包含的数据量。如果NtQueryObject返回STATUS_BUFFER_OVERFLOW或STATUS_BUFFER_TOO_SMALL,您可以使用变量的值来确定所需的缓冲区大小。 ' 返回值 ' NtQueryObject返回STATUS_SUCCESS或适当的错误状态。可能的错误状态码包括以下: ' 返回代码 描述 ' STATUS_ACCESS_DENIED ' 有足够的权限来执行该cha询。 ' STATUS_INVALID_HANDLE ' 提供对象句柄无效。 ' STATUS_INFO_LENGTH_MISMATCH ' 信息长度不足以容纳数据。 unicode ＝ 取空白字节集 (size) ZwQueryObject (handle, #ObjectTypeInformation, unicode, size, 0)' 读取信息的unicode文本 RtlUnicodeStringToAnsiString (ansi, unicode, 真)' 编码转换 ' RtlUnicodeStringToAnsiString例程将给定Unicode字符串转换成一个ANSI字符串。 str ＝ 指针到文本 (ansi.Buffer) ' RtlFreeAnsiString常规版本存储由RtlUnicodeStringToAnsiString分配。 ' 参数 ' AnsiString ' 指针ANSI字符串缓冲区由RtlUnicodeStringToAnsiString以前分配的。 RtlFreeAnsiString (ansi) str ＝ “无法获取”' 无效的怎么获取…… 返回 (str) 这一次呢更新了一个RemoteCloseHandle ，大概的原理是什么呢？ 同时也采用了一些比较骚的方法，这种方法的限制较多，但是对于32位进程就很有效果。 NtClose在MSDN的大概介绍 1. NtClose is a generic routine that operates on any type of object. 2. Closing an open object handle causes that handle to become invalid. The system also decrements the handle count for the object and checks whether the object can be deleted. The system does not actually delete the object until all of the object's handles are closed and no referenced pointers remain. 3. A driver must close every handle that it opens as soon as the handle is no longer required. Kernel handles, which are those that are opened by a system thread or by specifying the OBJ_KERNEL_HANDLE flag, can be closed only when the previous processor mo
读书笔记：提高C++性能的编程技术
qq_20189555的博客
07-24 478
第1章 跟踪范例 1.1 关注点 本章引入的实际问题为：定义一个简单的Trace类，将当前函数名输出到日志文件中。Trace对象会带来一定的开销，因此在默认情况下不会开启Trace功能。问题是：怎么设计Trace类，使得在不开启Trace功能时引入的开销最小。 1.2 使用状态变量开关功能 用宏来开关Trace功能很简单，在不开启时开销完全没有： #ifdef TRACE Trace trace(“aaa”); #endif 缺点是每次开关都需要重新编译。 使用状态变量的话有一定的运行时开销，但能保证灵活性
R3下用ZwQueryObject/ZwDuplicateObject关闭互斥体和解除文件占用
lixiangminghate的专栏
01-20 8216
不少程序在运行时会创建/打开全局Mutex，来限制用户多开。百度上搜一圈下来，他们的实现基本是这样: int main(int argc, char* argv[]) { HANDLE hMtx = CreateMutex(NULL,false,"process"); //创建一个有名对象，可以在其他进程中访问 if(GetLastError() == ERROR_ALREADY_EXIS
R3 x64枚举进程句柄
07-04 473
转载:https://blog.csdn.net/zhuhuibeishadiao/article/details/51292608 需要注意的是：在R3使用ZwQueryObject很容易锁死,需要放到线程中，如果线程超过500ms就说明卡死了 就只能放弃这个句柄了 这个句柄外面是一个FileObject类型,但真实是一个信号类型 还有在R3中枚举 有一个句柄我们是没有权限...
ZwQueryObject引起的OD无响应
天道酬勤
01-29 906
最近在使用OD调试一个程序的时候经常遇到OD无响应，查看无响应时的堆栈发现OD在调用ZwQueryObject时阻塞了，根据参数可知是是在查询一个文件的ObjectNameInformation，不清楚OD为什么要做这个操作，直接Patch掉OD的这段代码，竟然就正常了。 ...
解除游戏多开限制,关闭互斥体句柄
l198738655的博客
04-12 4875
(这里的防护建议是,增加多种多开限制的方法 以及 逻辑中增加多该互斥体的使用,这样可以避免直接被恶意关闭)比如说遍历窗口,遍历进程,配置文件,注册表,互斥体,mac地址,ip,公共文件,内存映射等等.方法很多.我们可以使用工具来查看互斥体,大家可以用XT,PCH等等工具。发现已经检测到我们开了一个窗口,只是没有进行限制。出现了很多句柄, 找到Mutant类型的句柄。我们逐一关闭,看看关闭哪个之后就可以多开窗口了。打开软件,找到我们的进程,右键查看句柄。很明显限制了多开,只能开2个。好的,我们的效果实现了.
GC-引用计数法
longtails的博客
04-08 2718
GC-引用计数法 GC:释放怎么都无法被引用的对象的机制。 引用计数法在对象的元数据区，加入了计数器，用于表示当前对象被引用了多少次。 引用计数法与其他GC算法相比，在于GC的的调用时机：GC标记-清除算法是在没有可用分块时，会调用GC函数，进行垃圾处理回收，即是一种无侵入式的GC,这样就造成，最大暂停时间较大,此外，标记-清除算法即是产生了垃圾，也不会将其马上回收，只会在没有分块的时候，将垃圾...
【iOS】引用计数与autorelease
weixin_72437555的博客
09-21 857
最近在学习iOS内存管理之引用计数，特此撰写博客记录学习过程自动引用计数（ARC）是指内存管理中对引用计数采取自动计数的方式在Objective-C中采用Automatic Reference Counting(ARC)机制，让编译器来进行内存管理。在新一代AppleLLVM编译器中设置ARC为有效状态，就无需再次键入retain或者release代码，这在降低程序崩溃、内存泄漏等风险的同时，很大程度上减少了开发程序的工作量。编译器完全清楚目标对象，并能立刻释放那些不再被使用的对象。
【iOS】引用计数
2301_79847748的博客
09-19 1620
我们可以用一个房间内开关灯来说明引用计数这个问题，当房间内进入第一个人时开灯，最后一个人离开时关灯，在这个过程中，需要照明的人数就是引用数。方法就可以实现，令对象在超出指定的生存范围时能够自动并正确的释放掉，在我们上文中举例的array就是通过调用。除了上述方法以外的方法生成的对象，因为不是自己生成并持有，所以自己不是该对象的持有者。我们在使用alloc等方法或者retain方法将持有者变成自己时，需要在不需要时释放该对象，但是。自己持有的对象，一旦不再需要时，持有者有义务释放该对象，使用。
iOS 中的引用计数
最新发布
weixin_43883776的博客
10-31 823
引用计数，溢出
【iOS】引用计数（一）
qq_73106050的博客
09-22 1573
笔者最近开始学习了一下有关于引用计数的内容，写这篇博客来简单认识一下引用计数部分的内容。我们可以通过一个开关灯的思路去理解这部分内容，正如上图所展示的，我们办公室在第一个人来的时候就要开灯，在最后一个人走后就要关灯，不能在当一个人走后就进行一个关灯操作，这样会影响其他人工作，所以只有当最后一个人离开办公室的时候再关灯就好了，这样才可以让其他人正常工作，而我们创建的对象可以理解为办公室里的照明设备，只要有一个人工作，照明设备就不可以被关闭。OC中对应的一个状态对照明设备的操作生成对象开灯持有对象。
引用计数与可达性分析
cdypa的博客
08-05 1308
一 GC的一些基本情况： GC收集情况：频繁收集年轻代，较少回收老年代，基本不动永久代(元空间)，由此可以看到，在GC中，大多数是对堆空间的回收 那么在java中，是如何判断一个对象是否是个垃圾呢？ 简单来说：当一个对已经不再被任何存活对象继续引用时，就可以宣布为死亡 二 判断对象是否存活的方式： 1.引用计数算法：引用计数算法(Reference Counting)比较简单，对每个对象保存一个整型的引用计数器属性，用于记录对象被引用的情况。 例如：有对象objA，与objB，如果objA指向了objB
内核函数 内核模块引用计数
yldfree的博客
07-05 3103
static inline int module_is_live(struct module *mod)功能:此函数为inline函数判断模块是否在活跃状态,如果不是MODULE_STATE_GOING(正在被卸载)状态，则就是活跃状态mod:模块的地址返回值: 为真或假头文件: #include &lt;linux/modle.h&gt;内核实现:(2.6.32)static inline in...
「OC」引用计数（一）
2301_80253909的博客
09-22 1203
引用计数的初次学习
【iOS】—— 引用计数
m0_62386635的博客
09-22 574
引用计数——MRC和ARC两种设计模式。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值