What about multithreading (C ++ lock)

[Disclaimer: All Rights Reserved. You are welcome to reprint it. Do not use it for commercial purposes. Contact Email: feixiaoxing @ 163.com]

Programming is not easy, but it is not easy to write multi-threaded programs. I believe that a program that has compiled multiple threads should have such a painful process. What is the situation? Friends should have a look at the code to understand,

void data_process(){    EnterCriticalSection();      if(/* error happens */)    {        LeaveCriticalSection();        return;    }    if(/* other error happens */)    {        return;    }    LeaveCriticalSection();}

The above code illustrates a situation. This multi-thread mutex situation is often encountered in the coding process. Therefore, each operation on shared data requires entercriticalsection and leavecriticalsection. However, this is not smooth sailing. You may encounter various errors. At this time, your program needs to jump out. You may need to exit the critical section when an error occurs at the beginning. However, if there are more errors, you may not remember this operation. This error is complete, and other threads have no chance to obtain the lock.
Is it possible to use the C ++ feature to automatically handle this situation? Yes. Let's look at the following code,

class CLock{    CRITICAL_SECTION& cs;public:    CLock(CRITICAL_SECTION& lock):cs(lock){        EnterCriticalSection(&cs);    }    ~CLock() {        LeaveCriticalSection(&cs);    }}class Process{    CRITICAL_SECTION cs;    /* other data */public:    Process(){        InitializeCriticalSection(&cs);    }    ~Process() {DeleteCriticalSection(&cs);}    void data_process(){        CLock lock(cs);        if(/* error happens */){            return;        }        return;    }}

An important feature of C ++ is that the system automatically calls class destructor no matter when the function exits. In the data_process function of the Process class, the function creates a clock class at the beginning. When this class is created, the primary key of the critical section is started. So once it enters the critical section, can the critical section be exited in time in error? At this time, the advantages of C ++ destructor have emerged. No matter when an error occurs, the system will help us after the function exits. What should we do? That is, the system will call the clock destructor, that is, exit the critical section. In this way, our goal is achieved.
In fact, this is a C ++ trick.