[QT] QT multithreading development - reentrancy and thread safety

Qt- Reentrancy and thread safety

One 、 Write it at the front

​ In this article , The term " Reentrancy " and " Thread safety " Used to mark classes and functions , Show how classes and functions can be used in multithreaded applications .

Reentrancy And Thread safety These two concepts are not Qt Unique concept , They are two important technical terms in the field of multithreading .

​ A thread safe function can be called by multiple threads at the same time , Even if these callers will use the shared data, there will be no problem , Because access to shared data is serial （serialized）、 The protected .
　 A reentrant function can also be called by multiple threads at the same time , But each caller can only use its own data （ That is, only the caller's information can be used ）.
　 therefore ： A thread safe function is always reentrant , But a reentrant function is not necessarily thread safe .

​ To start with , A reentrant class , It means that its member functions can be called safely by multiple threads , As long as each thread uses different objects of this class . And a thread safe class , It means that its member functions can be called safely by multiple threads , Even if all threads use the same instance of this class, it doesn't matter . So ： Thread safety Of “ Security ” than Reentrant function Of “ Security ” More secure .

​ 【 Be careful 】 Somewhat Qt Class is designed for multithreading , Only such classes exist Qt It is marked as thread safe in the official documents . If a function is not marked Thread safety or Reentrant Of , It should not be used by different threads . alike , If a class is not marked thread safe or reentrant , Instances of this class should not be accessed by multiple threads .

Two 、 Reentrancy

​ C++ Most classes of are reentrant , This is only because they can only access their own data . Any thread can access a member function of an instance of a reentrant class , As long as no other thread can call the member function of this instance . such as , Below Counter Classes are reentrant ：

class Counter  
{
    
   
public:
    Counter() {
     n = 0; }
    void increment() {
     ++n; }

    void decrement() {
     --n; }

    int value() const {
     return n; }
   
private:
	int n;
};

​ This class is not Thread safety Of , Because if multiple threads try to modify members n Words , The result is uncertain . because ++ and -- Operations are not always atomic . They are generally expanded into 3 A machine command ：

1.  Load variable values into registers 
2.  increase / Subtract the value in the register 
3.  Load the value in the register back into main memory 

​ If the thread A And thread B At the same time, load the old value of the variable into the register , Increase their registers , Reload main memory , They will eventually rewrite each other , The variable is only increased once ！

3、 ... and 、 Thread safety

​ Obviously , Yes n The access of should be serial ： Threads A Must be executed without interruption 3 A step （ Atomicity ）, Then the thread B To start its steps , Or vice versa . A simple way to make a class thread safe is ： Use one QMutex To protect all access to data members . The following code ：

class Counter 
{
    
   
 public:
    Counter() {
     n = 0; }
    void increment() {
     QMutexLocker locker(&mutex); ++n; }

    void decrement() {
     QMutexLocker locker(&mutex); --n; }

    int value() const {
     QMutexLocker locker(&mutex); return n; } 
 private: 
    mutable QMutex mutex;

    int n;
};

​ QMutexLocker Class is automatically locked in its constructor mutex, And unlock in its destructor . lock mutex It ensures that the access of other threads is serialized .

​ mutex Data members are declared as mutable Of , This is because value() It's a const function , But we need to be in it lock and unlock This mutex.

（ stay C++ in ,mutable It's for a breakthrough const It's set by the limit of , Can be used to modify the member variables of a class . By mutable Decorated variable , Will always be in a state of variability , Even if it's const You can also change the value of this variable in the function ）

Four 、 matters needing attention

​ many Qt All classes of are reentrant , But they are not thread safe , Because thread safety means locking and unlocking QMutex Add more expenses . such as ：QString It's reentrant , But it's not thread safe . You can access different from multiple threads at the same time QString Example , But it cannot be accessed from multiple threads at the same time QString The same example of （ Unless you use QMutex Protect access ）.