Shulou(Shulou.com)05/31 Report--

This article introduces the relevant knowledge of "instance analysis of thread synchronization and mutex in C++ multithreading". Many people will encounter this dilemma in the operation of actual cases. next, let the editor lead you to learn how to deal with these situations! I hope you can read it carefully and be able to achieve something!

Thread synchronization / * the case of using multi-threads to buy tickets. There are three windows, a total of 100 tickets. * / # include # include # include / / global variable, which is shared by all threads. Int tickets = 100void * sellticket (void * arg) {/ / ticket selling while (tickets > 0) {usleep (6000); / / microsecond printf ("% ld is selling% d tickets\ n", pthread_self (), tickets); tickets--;} return NULL;} int main () {/ / create 3 child threads pthread_t tid1, tid2, tid3 Pthread_create (& tid1, NULL, sellticket, NULL); pthread_create (& tid2, NULL, sellticket, NULL); pthread_create (& tid3, NULL, sellticket, NULL); / / recover the resources of child threads. The default blocking state pthread_join (tid1, NULL); pthread_join (tid2, NULL); pthread_join (tid3, NULL); / / sets thread separation. / / pthread_detach (tid1); / / pthread_detach (tid2); / / pthread_detach (tid3); pthread_exit (NULL); / / exit the main thread return 0;}

Running result:

Problems that arise:

Each ticket was sold several times.

It is wrong to sell the 0 th ticket and-1 ticket.

Three threads scramble for cpu resources.

Reason: dormant time, three processes go in to execute the program; multiple processes deal with shared resources at the same time, there will be thread synchronization problems.

The main advantage of threads: sharing information through global variables. However, this convenient sharing comes at a price: you must ensure that multiple threads do not modify the same variable at the same time, or that one thread does not read variables that are being modified by other threads.

Critical section: refers to a code snippet that accesses a shared resource, and the execution of this code should be atomic, that is, other threads accessing the same shared resource at the same time should not terminate the execution of the fragment.

Thread synchronization: when one thread is operating on memory, no other thread can operate on the memory address until the thread completes the operation. Other threads are in a waiting state.

Thread synchronization reduces the efficiency of thread concurrency, which is necessary.

Mutually exclusive quantity

To avoid problems when threads update shared variables, you can use mutexes (mutex) to ensure that only one thread can access a shared resource at the same time. Mutexes can be used to guarantee atomic access to any shared resource.

Mutexes have two states: locked (locked) and unlocked (unlocked).

At most one thread can lock the mutex at any one time. An attempt to lock a mutex that has been locked may block the thread or fail to report an error, depending on the method used to lock it.

Once the thread locks the mutex, it becomes the owner of the mutex, and only the owner can unlock the mutex.

In general, different mutexes will be used for each shared resource (which may be composed of multiple related variables), and each thread will use the following protocol when accessing the same resource:

Lock mutexes for shared resources

Access to shared resources

Unlock mutexes

Locking is the operation of shared data in the critical area.

If multiple threads try to execute this piece of code (a critical section), in fact only one thread can hold the mutex (other threads will be blocked), that is, only one thread can enter the code area at the same time, as shown in the following figure:

/ * Mutex type pthread_mutex_t int pthread_mutex_init (pthread_mutex_t * restrict mutex, const pthread_mutexattr_t * restrict attr) -initialize mutexes-parameters:-mutex: mutexes to be initialized-attr: mutexes related attributes, NULL-restrict: C language modifiers, modified pointers, which cannot be operated by another pointer. Pthread_mutex_t * restrict mutex = xxx; pthread_mutex_t * mutex1 = mutex;-cannot be operated in this way. There are restrict keywords int pthread_mutex_destroy (pthread_mutex_t * mutex);-release mutually exclusive resource int pthread_mutex_lock (pthread_mutex_t * mutex) -locking, blocking. If one thread is locked, other threads can only block waiting-successfully return 0 int pthread_mutex_trylock (pthread_mutex_t * mutex);-attempt to lock. If locking fails, it will not block and will return directly. Int pthread_mutex_unlock (pthread_mutex_t * mutex);-unlock the * / # include # include # include / / global variable, which is shared by all threads. Int tickets = 1000 sellticket / create a mutex-create pthread_mutex_t mutex;void * sellticket (void * arg) {/ / ticket selling while (1) {/ / lock pthread_mutex_lock (& mutex) in the global area; if (tickets > 0) {usleep (6000) Printf ("% ld is selling% d tickets\ n", pthread_self (), tickets); tickets--;} else {/ / unlock pthread_mutex_unlock (& mutex); break;} / / unlock pthread_mutex_unlock (& mutex);} return NULL } int main () {/ / initialize mutex pthread_mutex_init (& mutex, NULL); / / create three child threads pthread_t tid1, tid2, tid3; pthread_create (& tid1, NULL, sellticket, NULL); pthread_create (& tid2, NULL, sellticket, NULL); pthread_create (& tid3, NULL, sellticket, NULL); / / recover resources of child threads, blocking pthread_join (tid1, NULL) Pthread_join (tid2, NULL); pthread_join (tid3, NULL); pthread_exit (NULL); / / exit the main thread / / release mutex resources pthread_mutex_destroy (& mutex); return 0;} Thread synchronization and mutex instance analysis in C++ multithreading ends here. Thank you for reading. If you want to know more about the industry, you can follow the website, the editor will output more high-quality practical articles for you!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.