Mutex mutex

Celery notes ： 

The thread pool and token bucket are not learned ;

Debugging tips ： Count the time consumed by the program ;

The mutex ：

Atomic notes  

Mutex initialization ：

pthread_mutex_init() Function to initialize the mutex

pthread_mutex_t mutex;
pthread_mutex_init(&mutex, NULL);
 perhaps ：
pthread_mutex_t *mutex = malloc(sizeof(pthread_mutex_t));
pthread_mutex_init(mutex, NULL);

Mutex locking and unlocking

pthread_mutex_lock() Mutex locks can be locked 、 Get mutex ;

pthread_mutex_unlock() The mutex can be unlocked 、 Release the mutex ;

If the thread doesn't want to be blocked , have access to pthread_mutex_trylock() function

Destroy mutex

pthread_mutex_destroy() Function to destroy the mutex

• You cannot destroy a mutex that has not been unlocked , Otherwise, there will be a mistake ;
• Mutexes that are not initialized cannot be destroyed

Mutex deadlock

//  Threads  A
pthread_mutex_lock(mutex1);
pthread_mutex_lock(mutex2);
//  Threads  B
pthread_mutex_lock(mutex2);
pthread_mutex_lock(mutex1);

Mutex properties

pthread_mutex_init() When the function initializes the mutex, you can set the properties of the mutex
pthread_mutexattr_destroy() Destroy it
pthread_mutexattr_gettype() Function to get the mutex type attribute ,

pthread_mutexattr_settype() modify / Set the mutex type property , 

pthread_mutex_t mutex;
pthread_mutexattr_t attr;
/*  Initialize mutex property object  */
pthread_mutexattr_init(&attr);
/*  Set the type property to  PTHREAD_MUTEX_NORMAL */
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_NORMAL);
/*  Initialize mutex  */
pthread_mutex_init(&mutex, &attr);
......
/*  After use  */
pthread_mutexattr_destroy(&attr);
pthread_mutex_destroy(&mutex);

Interview questions ： In turn, print abcd

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include <unistd.h>

#define THRNUM 4

static pthread_mutex_t mut[THRNUM];

static int next(int n)
{
    if(n + 1 == THRNUM)
        return 0;
    return n + 1;    
}

static void *thr_func(void *p)
{
    int c;
    int n = (int)p;
    c = 'a' + n;
    while(1)
    {
        pthread_mutex_lock(mut+n);
        write(1, &c, 1);
        pthread_mutex_unlock(mut+next(n));
    }
    pthread_exit(NULL);
}

int main()
{
    pthread_t tid[THRNUM];
    int i, err;

    for(i = 0; i < THRNUM; i++)
    {
        
        pthread_mutex_init(mut+i, NULL);
        pthread_mutex_lock(mut+i);

        err = pthread_create(tid+i, NULL, thr_func, (void *)i);
        if(err)
        {
            fprintf(stderr, "pthread_create():%s\n", strerror(err));
            exit(1);
        }
    }

    pthread_mutex_unlock(mut+0);

    alarm(2 );
    
    for(i = 0; i < THRNUM; i++)
        pthread_join(tid[i], NULL);


    exit(0);
}