Shulou(Shulou.com)06/01 Report--

Editor to share with you how to use mutex mutex in Linux, I believe most people do not know much about it, so share this article for your reference, I hope you can learn a lot after reading this article, let's go to know it!

# # Mutex mutex

As mentioned earlier, if there is resource sharing, competition between threads, and there is no reasonable synchronization mechanism, there will be data confusion. In order to implement the synchronization mechanism, Linux provides a variety of ways, one of which is the mutex lock mutex (also known as mutex).

The specific implementation of the mutex is as follows: each thread tries to lock the shared resource before the operation, and can read and write to the shared resource only after the lock is successfully added, and unlocked after the operation is over.

Mutexes are not meant to eliminate competition. In fact, resources are shared and threads compete, but access to shared resources is turned into a mutually exclusive operation through this "lock" mechanism, that is, when a thread operates on the resource, other threads cannot operate it, thus eliminating time-related errors.

From the implementation mechanism of mutexes, we can see that only one thread can hold the lock at a time. It doesn't make sense if there are multiple threads holding the lock at the same time.

However, this locking mechanism is not mandatory. Mutex is essentially a "recommended lock" (also known as "cooperative lock") provided by the operating system, which is recommended to be used when multiple threads in the program access shared resources.

Therefore, even with mutex, other threads will still cause data confusion if they do not follow this locking mechanism to access shared data. So to avoid this, all threads accessing the shared resource must use the same locking mechanism.

Main application functions:

Pthread_mutex_init function

Pthread_mutex_destroy function

Pthread_mutex_lock function

Pthread_mutex_trylock function

Pthread_mutex_unlock function

The return values of the above five functions are: 0 for success and error number for failure.

In the Linux environment, the type pthread_mutex_t is essentially a structure. However, in order to simplify the understanding, the implementation details can be ignored and simply treated as integers. Mutex is generally defined in the following ways:

Pthread_mutex_t mutex

The variable mutex has only two values of 1 and 0.

# # pthread_mutex_init function

Function prototype:

Int pthread_mutex_init (pthread_mutex_t restrict mutex, const pthread_mutexattr_t restrict attr)

Function: initialize a mutex (mutex) mutex, and the initial value can be regarded as 1

Parameter description:

Mutex: outgoing parameter, which should be passed & mutex to the function when called

There is a special keyword here: restrict. Its function is only to limit the pointer, telling the compiler that all operations that modify the pointer to the contents of memory can only be done through this pointer. Cannot be modified by variables or pointers other than this pointer. For example, it is not allowed to define a pointer to pthread_mutex_t, assign it to the value of mutex, and want to use it to modify the memory pointed to by mutex.

Attr: mutex attribute. Is an incoming parameter, usually passed NULL, indicating the use of the default attribute (that is, sharing between threads).

There are two ways to initialize mutex mutex:

Static initialization: if the mutex mutex is statically assigned, that is, defined as a global variable, or modified with the static keyword, you can initialize it directly with a macro. E.g. Pthead_mutex_t muetx = PTHREAD_MUTEX_INITIALIZER

Dynamic initialization: if the mutex mutex is defined as a local variable, dynamic initialization should be used. E.g. Pthread_mutex_init (& mutex, NULL)

# # pthread_mutex_destroy function

Function prototype:

Int pthread_mutex_destroy (pthread_mutex_t * mutex)

Function: destroy a mutex

Pthread_mutex_lock function

Function prototype:

Int pthread_mutex_lock (pthread_mutex_t * mutex)

Function function:

Lock the shared resource. Can be understood as mutex-- (or-1)

If the lock is not successful, the thread blocks until the other thread holding the mutex is unlocked.

Note: lock it before accessing the shared resource and unlock it immediately after the access is over. The "granularity" of locks should be as small as possible.

Pthread_mutex_unlock function

Function prototype:

Int pthread_mutex_trylock (pthread_mutex_t * mutex)

Function function:

Unlock the shared resource. Can be understood as mutex + + (or + 1)

At the same time of unlocking, all threads blocked on the lock will be awakened. Which thread is awakened first depends on the priority and scheduling. By default: the thread that blocks first will be awakened first.

# # pthread_mutex_trylock function

Function prototype:

Int pthread_mutex_trylock (pthread_mutex_t * mutex)

Function: attempts to lock a shared resource. The difference between it and the pthread_mutex_lock function is that when using the lock function to lock a shared resource, if the locking is not successful, the thread is blocked; while if trylock is used, the current thread is not blocked when the locking is unsuccessful, but immediately returns a value to describe the condition of the mutex.

Deadlock:

The thread attempts to lock the same mutex A twice.

Thread 1 has A lock and requests B lock; thread 2 has B lock and requests A lock

# include # include pthread_mutex_t mutex;void * tfn (void * arg) {srand (time (NULL)); while (1) {pthread_mutex_lock (& mutex); printf ("hello"); / / Standard output is shared resource sleep (rand ()% 3); / / CPU printf ("world!\ n") will be lost at this time Pthread_mutex_unlock (& mutex); sleep (rand ()% 3);} return NULL;} int main () {pthread_t tid; int n = 5; srand (time (NULL)); pthread_mutex_init (& mutex, NULL); pthread_create (& tid, NULL, tfn, NULL); while (NLV -) {pthread_mutex_lock (& mutex) Printf ("HELLO"); sleep (rand ()% 3); printf ("WORLD!\ n"); pthread_mutex_unlock (& mutex); sleep (rand ()% 3);} pthread_cancel (tid); pthread_join (tid, NULL); pthread_mutex_destroy (& mutex); return 0 } these are all the contents of the article "how to use mutex mutex in Linux". Thank you for reading! I believe we all have a certain understanding, hope to share the content to help you, if you want to learn more knowledge, welcome to follow the industry information channel!

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.