C++ thread safety of static resources

Question

Say I have the following classes:

public class Item { 
public: 
  CString name;  
  int id;
  UINT type;
  bool valid;  
  void invalidate(){
    valid = false;
  }
  ...
}

public class itemPool { 
public: 
  static std::vector<Item*> items ; 
  void invalidateOfType(UINT type){
    for( auto iter : items )
       if ( iter->type == type )
         iter->invalidate();
  }
 ...
}

Can I call the "invalidateOfType(UINT type)" - method from different threads? Is there any possibility of "undefined behaviour" ? In other words, can I use static resources from in multiple threads ( make parallel calls to that resource ) ?

Answer 1

Static resources are no different than any shared resources. Unless their methods are thread-safe, they should not be called from multiple threads simultaneously. In your particular case, it boils down to the question of invalidate() being thread safe. Iterating over vector itself is thread-safe.

Quite unexpectedly (to me!) the question turned out into something very interesting and educational. Following are points of interest to remember here. In explaining those, I will take the code at the face value. I will also operate under the assumption (actually clarified by OP in some of the comments) that no code is READING while the invalidation takes place.

The code as written would iterate over the same vector at the same time. Since iterating the vector which is not modified during iteration is thread safe, this part is thread safe and needs no further discussion.

The second question is 'can two or more threads execute invalidateOfType for the same type at the same type'? If the answer is NO - every thread has it's own type - than again, the code is 100% thread safe, since same objects are not accessed from more than one thread and no further discussion is neccessary.

If the answer to the above question is 'YES', than we have a conondrum. Effectively it boils down to the question 'when two or more threads set the same memory location to the same value at the same time, is it going to produce unexpected results'? Precise reading of standards does not give a straight answer.

Answer 2

No, you cannot. This could result in two threads executing valid = false; at the same time on the same valid. It is not permissible to modify an object in one thread while another thread is, or might be, accessing it. (To be sure, check the docs for the particular threading model or library you are using, but most have this rule.)

I would consider this okay on Windows, because everyone does it. It's unlikely that some subsequent change to the platform will break everyone's code. I wouldn't do this on POSIX platforms because the documentation is pretty clear that it's not allowed and it's not commonly done.

Answer 3

If your question is, calling invalidateOfType() simultaniously from different threads lead to data curruption (one thread reading the other writing to the same object), then the answer is yes.

But you can protect the resource, in this example the items vector, with a std::mutex and std::lock_guard like:

class itemPool {
public:
   static std::vector<Item*> items;
   static std::mutex         items_mutex;

   void invalidateOfType(UINT type) {
      std::lock_guard< std::mutex > scoped_lock(items_mutex);
      for (auto iter : items)
         if (iter->type = type)
         {
            iter->invalidate();
         }
   }
   ...
}

If thread1 is just executing invalidateOfType and thread2 does a call to invalidateOfType, then thread2 has to wait until thread1 has left the function and the items_mutex is unlocked.

Do this with every resource you share accross threads to prevent corruption.

Answer 4

Can I call the "invalidateOfType(UINT type)" - method from different threads?

Dear god, no! Simply touching that array from another thread while the invalidateOfType function is running is sufficient to crash your program instantly. There's no locks anywhere.

At the very least you should lock (ie mutex) access to the array itself.