多年以后重发：多线程安全的变量模板

最新推荐文章于 2024-10-09 15:54:43 发布
最新推荐文章于 2024-10-09 15:54:43 发布
阅读量95 收藏
点赞数
文章标签： c/c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_33974433/article/details/85119882
版权
大家好，这里是我以xghome这个用户名，02年在CSDN上发布的《多线程安全的变量模板》，这次在《0bug -- C/C++商用工程之道》一书中，作为“资源锁”和多线程通信核心示例，也再次出现。
这个模板我当初大约写了19遍，写的有点长了，为了给广大读者省点事，我就把它粘贴过来了。嗯，原帖在这里： http://blog.csdn.net/xghome/archive/2002/05/28/15469.aspx
xghome是我2005年以前在CSDN使用的用户名，不过，可惜密码搞忘了，最要命的是，注册的21cn的邮箱也被废除，搞得我只有以tonyxiaohome这个用户名重出江湖。不过还是应该夸一句，CSDN对用户名和密码的保护，真的没话讲，呵呵，我怎么也没有办法恢复原用户名了。
嗯，这段代码是我的代码，我叫肖舸，拼音缩写XG，那个时侯还没用Tony.Xiao的英文名呢。大家注意了哈，可不是我欺世盗名，盗贴别人的帖子哈。
嗯，还有个旁证，我的《0bug -- C/C++商用工程之道》一书详细论述了我产生“资源锁”的原始动机和想法，这个模板主要就是基于“资源锁”在开发，这个思路目前我起码没有看到有其他人有过，从思路传承性上，我证明哈，这个东东是我的。呵呵。
文中代码很简单，大家只要把核心的模板代码拷贝下来，放到一个xgvar.h的头文件里面，就可以用，当然也可以是你喜欢的其他名字啦。不过注意啊，这个模板代码，在Windwos下可以使用，Linux下是不可以的，请关注，别用错了。
=========================================================
多线程的变量同步问题，一直是困扰广大VC程序员的一大难题，其主要表现是在多线程模式下，线程间共享变量的存取不再安全，程序员无法确保变量的值在存取时是否准确可信，对此，微软给出的解决方案是使用临界区对象加以保护。但是，临界区对象使用太过于繁琐，需要不断地加锁和解锁，很容易搞忘，引起新的Bug。
这里，东楼给出多线程安全的变量模板，由此模板，可派生绝大多数变量类型，实现线程间各种变量的安全互访。本模板已经重载了几乎全部运算符，大家可以很方便地使用＋＋、――、＋＝、－＝等操作，方便编程使用。
 
#ifndef _XiaoGeMVarTempleteHasBeenDefined_
#define _XiaoGeMVarTempleteHasBeenDefined_
#include <Afxmt.h>
 
template <class MVAR_TYPE>
class MVAR
{
public:
    MVAR()
    {
        m_pBegin=new char[sizeof(MVAR_TYPE)];
        memset(m_pBegin,0,sizeof(MVAR_TYPE));
    }
    ~MVAR(){delete[] m_pBegin;}
    int GetLength(){return sizeof(MVAR_TYPE);}
    MVAR_TYPE Set(MVAR_TYPE& value)
    {
        m_csLockHandle.Lock();
        memcpy(m_pBegin,(char*)&value,sizeof(MVAR_TYPE));
        m_csLockHandle.Unlock();
        return value;
    }
    MVAR_TYPE Get()
    {
        MVAR_TYPE myValue;
        m_csLockHandle.Lock();
        memcpy((char*)&myValue,m_pBegin,sizeof(MVAR_TYPE));
        m_csLockHandle.Unlock();
        return myValue;
    }
    MVAR_TYPE operator=(MVAR_TYPE value)
    {
        MVAR_TYPE myValue;
        m_csLockHandle.Lock();
        myValue=value;
        memcpy(m_pBegin,(char*)&myValue,sizeof(MVAR_TYPE));
        m_csLockHandle.Unlock();
        return myValue;
    }
    MVAR_TYPE operator~()
    {
        MVAR_TYPE myValue;
        m_csLockHandle.Lock();
        memcpy((char*)&myValue,m_pBegin,sizeof(MVAR_TYPE));
        myValue=~myValue;
        m_csLockHandle.Unlock();
        return myValue;
    }
    MVAR_TYPE operator++(int)
    {
        MVAR_TYPE myValue;
        m_csLockHandle.Lock();
        memcpy((char*)&myValue,m_pBegin,sizeof(MVAR_TYPE));
        myValue++;
        memcpy(m_pBegin,(char*)&myValue,sizeof(MVAR_TYPE));
        m_csLockHandle.Unlock();
        return myValue;
    }
    MVAR_TYPE operator++()
    {
        MVAR_TYPE myValue;
        m_csLockHandle.Lock();
        memcpy((char*)&myValue,m_pBegin,sizeof(MVAR_TYPE));
        myValue++;
        memcpy(m_pBegin,(char*)&myValue,sizeof(MVAR_TYPE));
        m_csLockHandle.Unlock();
        return myValue;
    }
    MVAR_TYPE operator--(int)
    {
        MVAR_TYPE myValue;
        m_csLockHandle.Lock();
        memcpy((char*)&myValue,m_pBegin,sizeof(MVAR_TYPE));
        myValue--;
        memcpy(m_pBegin,(char*)&myValue,sizeof(MVAR_TYPE));
        m_csLockHandle.Unlock();
        return myValue;
    }
    MVAR_TYPE operator--()
    {
        MVAR_TYPE myValue;
        m_csLockHandle.Lock();
        memcpy((char*)&myValue,m_pBegin,sizeof(MVAR_TYPE));
        myValue--;
        memcpy(m_pBegin,(char*)&myValue,sizeof(MVAR_TYPE));
        m_csLockHandle.Unlock();
        return myValue;
    }
    MVAR_TYPE operator+(MVAR_TYPE value)
    {
        MVAR_TYPE myValue;
        m_csLockHandle.Lock();
        memcpy((char*)&myValue,m_pBegin,sizeof(MVAR_TYPE));
        myValue+=value;
        m_csLockHandle.Unlock();
        return myValue;
    }
    MVAR_TYPE operator-(MVAR_TYPE value)
    {
        MVAR_TYPE myValue;
        m_csLockHandle.Lock();
        memcpy((char*)&myValue,m_pBegin,sizeof(MVAR_TYPE));
        myValue-=value;
        m_csLockHandle.Unlock();
        return myValue;
    }
    MVAR_TYPE operator*(MVAR_TYPE value)
    {
        MVAR_TYPE myValue;
        m_csLockHandle.Lock();
        memcpy((char*)&myValue,m_pBegin,sizeof(MVAR_TYPE));
        myValue*=value;
        m_csLockHandle.Unlock();
        return myValue;
    }
    MVAR_TYPE operator/(MVAR_TYPE value)
    {
        MVAR_TYPE myValue;
        m_csLockHandle.Lock();
        memcpy((char*)&myValue,m_pBegin,sizeof(MVAR_TYPE));
        myValue/=value;
        m_csLockHandle.Unlock();
        return myValue;
    }
    MVAR_TYPE operator&(MVAR_TYPE value)
    {
        MVAR_TYPE myValue;
        m_csLockHandle.Lock();
        memcpy((char*)&myValue,m_pBegin,sizeof(MVAR_TYPE));
        myValue&=value;
        m_csLockHandle.Unlock();
        return myValue;
    }
    MVAR_TYPE operator|(MVAR_TYPE value)
    {
        MVAR_TYPE myValue;
        m_csLockHandle.Lock();
        memcpy((char*)&myValue,m_pBegin,sizeof(MVAR_TYPE));
        myValue|=value;
        m_csLockHandle.Unlock();
        return myValue;
    }
    MVAR_TYPE operator^(MVAR_TYPE value)
    {
        MVAR_TYPE myValue;
        m_csLockHandle.Lock();
        memcpy((char*)&myValue,m_pBegin,sizeof(MVAR_TYPE));
        myValue^=value;
        m_csLockHandle.Unlock();
        return myValue;
    }
    MVAR_TYPE operator+=(MVAR_TYPE value)
    {
        MVAR_TYPE myValue;
        m_csLockHandle.Lock();
        memcpy((char*)&myValue,m_pBegin,sizeof(MVAR_TYPE));
        myValue+=value;
        memcpy(m_pBegin,(char*)&myValue,sizeof(MVAR_TYPE));
        m_csLockHandle.Unlock();
        return myValue;
    }
    MVAR_TYPE operator-=(MVAR_TYPE value)
    {
        MVAR_TYPE myValue;
        m_csLockHandle.Lock();
        memcpy((char*)&myValue,m_pBegin,sizeof(MVAR_TYPE));
        myValue-=value;
        memcpy(m_pBegin,(char*)&myValue,sizeof(MVAR_TYPE));
        m_csLockHandle.Unlock();
        return myValue;
    }
    MVAR_TYPE operator*=(MVAR_TYPE value)
    {
        MVAR_TYPE myValue;
        m_csLockHandle.Lock();
        memcpy((char*)&myValue,m_pBegin,sizeof(MVAR_TYPE));
        myValue*=value;
        memcpy(m_pBegin,(char*)&myValue,sizeof(MVAR_TYPE));
        m_csLockHandle.Unlock();
        return myValue;
    }
    MVAR_TYPE operator/=(MVAR_TYPE value)
    {
        MVAR_TYPE myValue;
        m_csLockHandle.Lock();
        memcpy((char*)&myValue,m_pBegin,sizeof(MVAR_TYPE));
        myValue/=value;
        memcpy(m_pBegin,(char*)&myValue,sizeof(MVAR_TYPE));
        m_csLockHandle.Unlock();
        return myValue;
    }
    MVAR_TYPE operator&=(MVAR_TYPE value)
    {
        MVAR_TYPE myValue;
        m_csLockHandle.Lock();
        memcpy((char*)&myValue,m_pBegin,sizeof(MVAR_TYPE));
        myValue&=value;
        memcpy(m_pBegin,(char*)&myValue,sizeof(MVAR_TYPE));
        m_csLockHandle.Unlock();
        return myValue;
    }
    MVAR_TYPE operator|=(MVAR_TYPE value)
    {
        MVAR_TYPE myValue;
        m_csLockHandle.Lock();
        memcpy((char*)&myValue,m_pBegin,sizeof(MVAR_TYPE));
        myValue|=value;
        memcpy(m_pBegin,(char*)&myValue,sizeof(MVAR_TYPE));
        m_csLockHandle.Unlock();
        return myValue;
    }
    MVAR_TYPE operator^=(MVAR_TYPE value)
    {
        MVAR_TYPE myValue;
        m_csLockHandle.Lock();
        memcpy((char*)&myValue,m_pBegin,sizeof(MVAR_TYPE));
        myValue^=value;
        memcpy(m_pBegin,(char*)&myValue,sizeof(MVAR_TYPE));
        m_csLockHandle.Unlock();
        return myValue;
    }
    BOOL operator>(MVAR_TYPE value)
    {
        MVAR_TYPE myValue;
        BOOL bRet;
        m_csLockHandle.Lock();
        memcpy((char*)&myValue,m_pBegin,sizeof(MVAR_TYPE));
        bRet=(myValue>value);
        m_csLockHandle.Unlock();
        return bRet;
    }
    BOOL operator<(MVAR_TYPE value)
    {
        MVAR_TYPE myValue;
        BOOL bRet;
        m_csLockHandle.Lock();
        memcpy((char*)&myValue,m_pBegin,sizeof(MVAR_TYPE));
        bRet=(myValue<value);
        m_csLockHandle.Unlock();
        return bRet;
    }
    BOOL operator>=(MVAR_TYPE value)
    {
        MVAR_TYPE myValue;
        BOOL bRet;
        m_csLockHandle.Lock();
        memcpy((char*)&myValue,m_pBegin,sizeof(MVAR_TYPE));
        bRet=(myValue>=value);
        m_csLockHandle.Unlock();
        return bRet;
    }
    BOOL operator<=(MVAR_TYPE value)
    {
        MVAR_TYPE myValue;
        BOOL bRet;
        m_csLockHandle.Lock();
        memcpy((char*)&myValue,m_pBegin,sizeof(MVAR_TYPE));
        bRet=(myValue<=value);
        m_csLockHandle.Unlock();
        return bRet;
    }
    BOOL operator==(MVAR_TYPE value)
    {
        MVAR_TYPE myValue;
        BOOL bRet;
        m_csLockHandle.Lock();
        memcpy((char*)&myValue,m_pBegin,sizeof(MVAR_TYPE));
        bRet=(myValue==value);
        m_csLockHandle.Unlock();
        return bRet;
    }
    BOOL operator!=(MVAR_TYPE value)
    {
        MVAR_TYPE myValue;
        BOOL bRet;
        m_csLockHandle.Lock();
        memcpy((char*)&myValue,m_pBegin,sizeof(MVAR_TYPE));
        bRet=(myValue!=value);
        m_csLockHandle.Unlock();
        return bRet;
    }
private:
    char* m_pBegin;
    CCriticalSection m_csLockHandle;
};
 
typedef MVAR<char>              MCHAR;
typedef MVAR<unsigned char>       MUCHAR;
typedef MVAR<short>             MSHORT;
typedef MVAR<unsigned short>    MUSHORT;
typedef MVAR<int>               MINT;
typedef MVAR<unsigned int>        MUINT;
typedef MVAR<long>              MLONG;
typedef MVAR<unsigned long>       MULONG;
typedef MVAR<float>             MFLOAT;
typedef MVAR<double>            MDOUBLE;
typedef MVAR<BOOL>              MBOOL;
typedef MVAR<LPVOID>            MLPVOID;
typedef MVAR<BYTE>              MBYTE;
 
#endif //_XiaoGeMVarTempleteHasBeenDefined_
 
    大家只需要把这段代码放入Mvar.h文件，在stdafx.h中include这个头文件，即可在程序中自由使用变量。以上仅仅是东楼根据自己的需要，派生的几个常用类型，大家也可以尝试派生新的类型使用。
    注意，当派生的变量需要取得其中的值时，必须使用.Get()成员函数，这是唯一一点不如普通变量方便的地方。
    下面给出一个控制例子，大家可以参考：
 
#includen “mvar.h”
class CMyClass
{
public:
    CMyClass();
    ~ CMyClass();
protected:
    static UINT MyThread(LPVOID pParam);    //线程函数
    MBOOL m_bThreadContinue;           //线程循环标志
    MUINT m_nThreadCount;              //线程计数器
};
 
CMyClass::CMyClass()
{
    m_bThreadContinue=TRUE;
    m_nThreadCount=0;
    int i;
    //开启100个线程
    for(i=0;i<100;i++)
    {
        m_nThreadCount++;                //一定要在开启线程前累加线程计数器
        AfxBeginThread(MyThread,this);    //开启线程，以本对象指针为参数
}
}
CMyClass::~CMyClass()
{
    m_bThreadContinue=FALSE;  //通知线程关闭
    while(m_nThreadCount!=0) {}   //等待所有线程退出
    //此时退出，线程已经全部安全退出!!!
}
UINT CMyClass::MyThread(LPVOID pParam)
{
    CMyClass* pThis=(CMyClass*)pParam;    //得到本对象指针
    while(pThis->m_bThreadContinue)
    {
        //循环体
        Sleep(100);
}
pThis->m_nThreadCount --; //线程计数器减1
return 0;
} 
如果有问题，欢迎大家提问，如果有Bug,也请大家及时向东楼提出。
 
weixin_33974433
关注
Java 理论与实践: 正确使用 volatile 变量 线程同步
12-22
　这样当多个线程同时与某个对象交互时，必须要注意到要让线程及时的得到共享成员变量的变化。 　而volatile关键字是提示VM：对于这个成员变量不能保存它的私有拷贝，而应直接与共享成员变量交互。 　使用建议：...
多线程安全的变量模板
xghome的专栏
05-28 917
多线程的变量同步问题，一直是困扰广大VC程序员的一大难题，其主要表现是在多线程模式下，线程间共享变量的存取不再安全，程序员无法确保变量的值在存取时是否准确可信，对此，微软给出的解决方案是使用临界区对象加以保护。但是，临界区对象使用太过于繁琐，需要不断地加锁和解锁，很容易搞忘，引起新的Bug。这里，东楼给出多线程安全的变量模板，由此模板，可派生绝大多数变量类型，实现线程间各种变量的安全互访。本模
python笔记8--命令行解析Argparse
脚步不能达到的地方，眼光可以达到；眼光不能达到的地方，精神可以飞到
02-02 254
python笔记7--命令行解析Argparsepython笔记7--命令行解析Argparse功能源码案例说明 python笔记7–命令行解析Argparse python获取输入参数的方式有多种，一种使用sys.argv获取输入的参数，然后根据值判断是否包括某个参数；第二种使用Argparse来获取和设置参数，该方法较实用，笔者查阅了相关资料并加以整理，放在此处以便于后续查阅和学习！ 功能 ...
多线程下变量安全问题
aai00180的博客
01-29 612
（一）静态变量：线程非安全 　 1、静态变量：使用static关键字定义的变量。static可以修饰变量和方法，也有static静态代码块。被static修饰的成员变量和成员方法独立于该类的任何对象。也就是说，它不依赖类特定的实例，被类的所有实例共享。 　　　 只要这个类被加载，Java虚拟机就能根据类名在运行时数据区的方法区内定找到他们。因此，static对象可以在它的任何对象...
2022年多线程安全的变量模板C语言教程.docx
07-13
本教程提供的“多线程安全的变量模板”是一种设计模式，用于确保在多线程环境下对特定变量类型进行安全的操作。 首先，模板类`MVAR`通过定义一个内部的`MVAR_TYPE`类型参数，可以适用于任意基本数据类型或者自定义...
大漠多线程模板_大漠_大漠多线程_
09-30
"大漠多线程模板"是一个专门针对C#开发的多线程处理框架，它为开发者提供了便捷的方式来管理和优化多线程应用。这个框架由知名开发者"大漠"创建，旨在简化复杂的并发编程，提高代码的可读性和可维护性。 多线程允许...
C语言多线程中变量累加问题的分析
07-29
3. 使用线程安全的变量：我们可以使用线程安全的变量来代替`g_iTestInteger`变量。 变量累加问题是多线程编程中的一个非常重要的问题。我们需要使用适当的方法来解决变量累加问题，以确保程序的正确性和可靠性。 ...
CVI 线程锁、线程安全变量实例
11-07
本实例将深入探讨如何在LabWindows/CVI中有效地使用线程锁和线程安全变量来实现多线程程序设计。 首先，我们来看线程锁。线程锁，也称为互斥锁，是一种同步机制，用于确保同一时间只有一个线程可以访问特定的资源或...
c++线程安全的map
热门推荐
clh01s的博客
05-17 1万+
参考了 《c++并发编程实战》这本书上的代码写了一个线程安全可以并发的map/* * threadsafe_map.cpp * * Created on: May 11, 2018 * Author: clh01s * 线程安全的查找表 * 通过boost的shared_mutex实现读写锁 * 假设有一定数量的桶，每一个键都有一个桶 * ...
C语言 | 第十章 | 函数 作用域
ZJC744575的博客
10-05 1209
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
C++学习笔记----8、掌握类与对象（四）---- 不同类型的数据成员（1）
weixin_71738303的博客
10-05 922
c++对于数据成员给了你许多选项。除了在类中声明简单的数据成员，可以生成静态数据成员供所有类的对象共享，const成员，引用成员，reference-to-const成员，等等。本节我们解释一下这些不同类型的数据成员的细节。
【C++算法】9.双指针_四数之和
hlyd520的博客
10-04 580
后面的步骤类似，就不多赘述了。解法一：排序+暴力枚举+利用。双指针遇到合适的数继续往后走。解法二：排序+双指针。不满足循环条件，跳出。
C++继承的三种方式[ACCESS]
阿江的故事
10-02 474
两个类的继承关系在派生类中声明，由[ACCESS]的这三个值，从而引出了C++继承的三种方式......
国庆刷题（day1)
m0_69261119的博客
10-02 244
全对实在是太难了，我尽力了。
windows C++-创建数据流代理(三)
苏洛的博客
10-08 286
控制流指的是程序中操作的执行顺序。 控制流是通过使用条件语句、循环等控制结构调节的。 此外，数据流指的是一种编程模型，在这种模型中，只有当所有需要的数据都可用时，才会进行计算。 数据流编程模型与消息传递这一概念相关，其中程序的独立组件通过发送消息相互通信。 异步代理同时支持控制流和数据流编程模型。 尽管控制流模型适用于许多情况，但数据流模型也适用于其他一些情况，例如，当代理接收数据并执行基于该数据的有效负载的操作时。
stm32f103调试，程序与定时器同步设置
m0_74644005的博客
10-03 474
在调试定时器相关代码时，注意到定时器的中断位总是置1，怀疑代码有问题，经过增大定时器的中断时间，发现定时器与代码调试并不同步，这一点对于调试涉及定时器的代码是非常不利的，这里给出keil调试stm32使定时器与代码同步的设置方法。点击下面的use custom SVD file ,然后点击文件选择，粘贴路径进入，选择调试的芯片，这里使用的使stm32f103，所以选择STM32F103xx.SFR，保存后重启keil，
31 类和对象 · 上
最新发布
m0_66277256的博客
10-09 409
类与对象的学习总结
多线程编程陷阱：全局变量与线程安全
在多线程编程中，一个常见的问题涉及到对全局变量的共享访问。当你在一个或多线程环境下，多个线程同时调用一个函数，该函数操作共享的全局变量时，可能会遇到意想不到的问题。例如，在给出的C++代码片段中，`check_...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值