# V5012. OWASP. Potentially unsafe double-checked locking.

The analyzer has detected a potential error that has to do with unsafe use of the "double-checked locking" pattern. This pattern is used to reduce the overhead of acquiring a lock. First the locking criterion is checked without synchronization, and only if this criterion is met, will the thread attempt to acquire the lock. That is, locking will occur only if the check indicates that locking is required.

Consider the following example:

    static std::mutex mtx;
    class TestClass
    {
    public:
      void Initialize()
      {
        if (!initialized)
        {
          std::lock_guard lock(mtx);
          if (!initialized) // <=
          {
            resource = new SomeType();
            initialized = true;
          }
        }
      }
      /* .... */

      private:
        bool initialized = false;
        SomeType *resource = nullptr;
      };
    }

In this example, the compiler optimizes the order of assigning values to the variables 'resource' and 'initialized', which could lead to an error. That is, the 'initialized' variable will be assigned the value 'true' first and only then will the memory for an object of type 'SomeType' be allocated and the variable 'resource' initialized.

Because of this inversion, an error may occur when the object is accessed from another thread: the 'resource' variable will not be initialized yet, while the 'intialized' flag will be already set to 'true'.

One of the problems with this type of errors is that the program seems to be running correctly since the described situation will occur only every now and then, depending on the processor's architecture.

Additional links:

- Scott Meyers and Andrei Alexandrescu. C++ and the Perils of Double-Checked Locking.
- Stack Overflow. What the correct way when use Double-Checked Locking with memory barrier in c++?

This diagnostic is classified as:

CWE-609 OWASP-1.11.3 OWASP-11.1.6