How to solve the problem of Linux multi-threading and multi-thread concurrent access to the same memory

Why do we need multi-threading?

• The ability of parallel entities to share the same address space and all available data cannot be expressed by multi-process locks because multiple processes have different address spaces;

• Threads are more lightweight and faster than processes;

• When a large amount of IO processing and calculations are required, having multiple threads can significantly improve performance;

• In multi-CPU systems, multi-threading is beneficial. In such a system, physical multi-threaded parallel operation can truly be realized;

Advantages of multi-threading

• Speed ​​up program response;

• When there are no tasks that need to be processed, processor time can be given to other tasks Task;

• Tasks that take up a lot of processing time can periodically give up processor time to other tasks;

• The task can be stopped at any time;

• You can set the priority of each task separately to optimize performance;

Best application scenario

• Time-consuming or processor-intensive tasks block user interface operations;

• Each task must wait for external resources; (such as a remote connection or INternet connection)

Disadvantages of multi-threading

• Waiting for shared resources will slow down the running speed of the program. These shared resources are mainly exclusive resources, such as printers;

• Managing threads requires additional CPU overhead;

• Thread deadlock, that is, long wait or resource competition,

• Simultaneous reading or writing of public variables often produces unpredictable errors

Verification ideas

Reading or writing to the same global variable (initial value is 0 ), use five thread functions to operate, each thread function 1000 times. Therefore, our 5 threads should be 5000 times, and the final value of the global variable should be 5000.

Performed different attempts and found that the wg value was sometimes 5000, sometimes 4997 or 4998.

The reason is:

What we do with wg is not an atomic operation. It is converted into instructions. It consists of multiple instructions. The binary instructions executed by the computer automatically change the variables. This operation is divided into many steps. For example, there are two threads reading wg

, but it cannot be completed at once. First, val is read, and then, read back. This operation is not over yet, and another thread Also read wg, and then read it back. It is possible that two threads add wg=1;, but the final value is 2.

We can't just consider the problem at the code level. We also need to consider the environment in which the code runs. Observing the settings of our virtual machine, we found that there are 4 processors, and at least two processors are processing other threads. There is a situation where one thread is placed on two processors and accessed at the same time. The probability of occurrence is less than 5000 is relatively high, which is also caused by parallel execution.

After only one processor is enabled, only one thread is executing, and the other four threads are definitely not executing. There is no situation where two threads are executed at the same time.

The probability of appearing less than 5000 is very small (the reason is that after reading the val value 1, there is no time to go back. At this time, the time slice has arrived, and a switch has occurred. When switching to other threads, the read value is still 1. Add and add, on-site recovery, or add and add with 1. The probability of this scenario occurring is very small) One processor cannot be parallelized.

The above is the detailed content of How to solve the problem of Linux multi-threading and multi-thread concurrent access to the same memory. For more information, please follow other related articles on the PHP Chinese website!