【问题标题】:ID generator with local static variable - thread-safe?具有局部静态变量的 ID 生成器 - 线程安全?
【发布时间】:2010-04-24 18:35:24
【问题描述】:

以下代码在多线程场景中会按预期工作吗?

int getUniqueID()  
{  
    static int ID=0;  
    return ++ID;  
}

ID 不必是连续的 - 即使它跳过了一个值,也没关系。 是不是说这个函数返回时,返回的值在所有线程中都是唯一的?

【问题讨论】:

    标签: c++ c thread-safety


    【解决方案1】:

    不,不会。您的处理器将需要执行以下步骤来执行此代码:

    • 从内存中获取 ID 值到寄存器
    • 增加寄存器中的值
    • 将增量值存储到内存中

    如果在此(非原子)序列期间发生线程切换,则可能发生以下情况:

    • 线程 a 将值 1 提取到寄存器中
    • 线程 a 增加值,因此寄存器现在包含 2
    • 上下文切换
    • 线程 b 获取值 1(仍在内存中)
    • 上下文切换
    • 线程 a 将 2 存储到内存并返回
    • 上下文切换
    • 线程 b 将其存储在其寄存器中的值增加到 2
    • 线程 b(也)将值 2 存储到内存并返回 2

    所以,两个线程都返回 2。

    【讨论】:

      【解决方案2】:

      不,竞争仍然存在,因为增量不一定是原子的。如果您使用原子操作来增加 ID,这应该可以工作。

      【讨论】:

        【解决方案3】:

        如果您只需要跨 N 个线程的一些单调递增(或非常接近)的数字,请考虑这个(k 是某个数字,使得 2^k > N):

        int getUniqueIDBase()  
        {  
            static int ID=0;  
            return ++ID;  
        }
        
        int getUniqueID()
        {
            return getUniqueIDBase() << k + thread_id;
        }
        

        【讨论】:

        • 这很创新。 +1
        【解决方案4】:

        ++ 不一定是原子的,所以不,这不是线程安全的。但是,很多 C 运行时都提供原子版本,例如 gcc 的 __sync_add_and_fetch() 和 Windows 上的 InterlockedIncrement()。

        【讨论】:

          【解决方案5】:

          getUniqueID 至少有两个竞争条件。在初始化ID 和递增ID 时。我重写了函数以更清楚地显示数据竞争。

          int getUniqueID()  
          {
             static bool initialized = false;
             static int ID;
             if( !initialized )
             {
                sleep(1);
                initialized = true;
          
                sleep(1);
                ID = 1;      
             }
          
             sleep(1);
             int tmp = ID;
          
             sleep(1);
             tmp += 1;
          
             sleep(1);
             ID = tmp;
          
             sleep(1);
             return tmp;
          }
          

          递增具有欺骗性,它看起来很小,以至于认为它是原子的。然而,它是一个加载-修改-存储操作。将值从内存加载到 CPU 寄存器。 inc 注册。将寄存器存储回内存。

          使用新的 c++0x 你可以只使用std::atomic 类型。

          int getUniqueID()  
          {  
              static std::atomic<int> ID{0};  
              return ++ID;  
          }
          

          注意:从技术上讲,我撒了谎。零初始化的全局变量(包括函数静态变量)可以存储在 bss 内存中,一旦程序启动就不需要初始化。但是,增量仍然是一个问题。

          【讨论】:

          • ID 的初始化是线程安全的,因为具有static 存储持续时间的变量的初始化是在程序启动时完成的
          【解决方案6】:

          注意:使用 almost 这个词是因为全局变量将在进程启动时被初始化(即它的构造函数将在进入main 之前被调用),而函数内部的静态变量将在第一次执行语句时初始化。

          你的问题从一开始就错了:

          具有局部静态变量的 ID 生成器 - 线程安全?

          在 C/C++ 中,函数内部或类/结构声明内部的静态变量的行为(几乎)类似于全局变量,而不是基于局部堆栈的变量。

          以下代码:

          int getUniqueID()  
          {  
              static int ID=0;  
              return ++ID;  
          }
          

          将(几乎)类似于伪代码:

          private_to_the_next_function int ID = 0 ;
          
          int getUniqueID()  
          {  
              return ++ID;  
          }
          

          使用伪关键字 private_to_the_next_function 使变量对所有其他函数不可见,但 getUniqueId...

          这里,static 只是隐藏了变量,使得其他函数无法访问它...

          但即使隐藏,变量 ID 仍然是全局变量:如果 getUniqueId 被多个线程调用,ID 将与其他全局变量一样是线程安全的,也就是说,根本不是线程安全的.

          编辑:变量的生命周期

          看完cmets后,我觉得我的答案不够清楚。我没有使用全局/本地概念来表示它们的范围含义,而是使用它们的生命周期含义:

          只要进程正在运行,全局就会存在,而分配在堆栈上的局部将在进入作用域/函数时开始其生命,并在退出作用域/函数时停止存在.这意味着全局将保留其价值,而本地则不会。这也意味着全局将在线程之间共享,而本地则不会。

          在其中添加 static 关键字,该关键字根据上下文具有不同的含义(这就是为什么不推荐在全局变量和 C++ 中的函数上使用 static 以支持匿名命名空间,但我离题了)。

          当限定一个局部变量时,这个局部变量的行为不再像一个局部变量。它成为隐藏在函数内部的全局变量。所以它的行为就好像一个局部变量的值在函数调用之间被神奇地记住了,但这并不神奇:该变量是一个全局变量,并且在程序结束之前将保持“活动”。

          您可以通过在函数内记录声明为静态的对象的创建和销毁来“看到”这一点。构造会在声明语句执行时发生,而销毁会在进程结束时发生:

          bool isObjectToBeConstructed = false ;
          int iteration = 0 ;
          
          struct MyObject
          {
             MyObject() { std::cout << "*** MyObject::MyObject() ***" << std::endl ; }
             ~MyObject() { std::cout << "*** MyObject::~MyObject() ***" << std::endl ; }
          };
          
          void myFunction()
          {
             std::cout << "   myFunction() : begin with iteration " << iteration << std::endl ;
          
             if(iteration < 3)
             {
                ++iteration ;
                myFunction() ;
                --iteration ;
             }
             else if(isObjectToBeConstructed)
             {
                static MyObject myObject ;
             }
          
             std::cout << "   myFunction() : end with iteration " << iteration << std::endl ;
          }
          
          
          int main(int argc, char* argv[])
          {
             if(argc > 1)
             {
                std::cout << "main() : begin WITH static object construction." << std::endl ;
                isObjectToBeConstructed = true ;
             }
             else
             {
                std::cout << "main() : begin WITHOUT static object construction." << std::endl ;
                isObjectToBeConstructed = false ;
             }
          
             myFunction() ;
          
             std::cout << "main() : end." << std::endl ;
             return 0 ;
          }
          

          如果你在没有参数的情况下启动可执行文件,执行将永远经过静态对象声明,因此,它永远不会被构造或破坏,如日志所示:

          main() : begin WITHOUT static object construction.
             myFunction() : begin with iteration 0
             myFunction() : begin with iteration 1
             myFunction() : begin with iteration 2
             myFunction() : begin with iteration 3
             myFunction() : end with iteration 3
             myFunction() : end with iteration 2
             myFunction() : end with iteration 1
             myFunction() : end with iteration 0
          main() : end.
          

          但是如果你使用参数启动它,那么对象将在 myFunction 的第三次递归调用中构造,并且仅在进程结束时销毁,如日志所示:

          main() : begin WITH static object construction.
             myFunction() : begin with iteration 0
             myFunction() : begin with iteration 1
             myFunction() : begin with iteration 2
             myFunction() : begin with iteration 3
          *** MyObject::MyObject() ***
             myFunction() : end with iteration 3
             myFunction() : end with iteration 2
             myFunction() : end with iteration 1
             myFunction() : end with iteration 0
          main() : end.
          *** MyObject::~MyObject() ***
          

          现在,如果您使用相同的代码,但通过多个线程调用 myFunction,您将在 myObject 的构造函数上出现竞争条件。如果你调用这个 myObject 方法或在多个线程调用的 myFunction 中使用这个 myObject 变量,你也会有竞争条件。

          因此,静态局部变量 myObject 只是隐藏在函数中的全局对象。

          【讨论】:

          • 不正确。静态局部变量具有局部作用域,但其值在函数调用中保留。 Global 和 Local 指的是范围,而不是存储类。
          • 静态局部变量可以返回,只要调用者不修改它们。它们仍然在分配它们的函数中。
          • @WhirlWind:我更正了我的答案以澄清我使用“全局”和“本地”词来指定变量的生命周期,这在多线程上下文中真正重要。
          • @Tim Post:可以返回静态局部变量。事实上,您甚至可以返回指向它们的引用/指针并让调用者修改它们。在多线程上下文中,这可能会产生有趣的结果。它们显然是“作用域的”这一事实不会改变它们的生命周期不是普通局部变量的生命周期,而是全局变量的生命周期这一事实。
          猜你喜欢
          • 2014-12-24
          • 1970-01-01
          • 1970-01-01
          • 1970-01-01
          • 1970-01-01
          • 1970-01-01
          • 1970-01-01
          • 2011-11-18
          相关资源
          最近更新 更多