线程互斥锁

Posted 2021-04-24 嵌入式图像处理

互斥之互斥锁

posix互斥锁

互斥锁是用一种简单的加锁方法来控制对共享资源的原子操作。这个互斥锁只有两种状态，也就是上锁和解锁，
可以把互斥锁看作某种意义上的全局变量。在同一时刻只能有一个线程掌握某个互斥锁，拥有上锁状态的线程能够对共享资源进行操作。
若其他线程希望上锁一个已经被上锁的互斥锁，则该线程就会阻塞挂起，直到上锁的线程释放掉互斥锁为止。
任务访问临界资源前申请锁，访问完后释放锁
头文件
#include  <pthread.h>

互斥锁初始化

int pthread_mutex_init(pthread_mutex_t *mutex,

                       const pthread_mutexattr_t *  attr);
返回0，失败返回错误码

mutex 指向要初始化的互斥锁对象
attr  互斥锁属性，NULL表示缺省属性

申请锁

int pthread_mutex_lock(pthread_mutex_t *mutex);
返回0，失败时返回错误码

mutex  指向要初始化的互斥锁对象
如果无法获得锁，任务阻塞

释放锁

int pthread_mutex_unlock(pthread_mutex_t *mutex);
返回0，失败返回错误码

mutex  指向要初始化的互斥锁对象
执行完临界区要及时释放锁

销毁锁

int pthread_mutex_destroy(pthread_mutex_t *mutex);
返回0，失败返回错误码 

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

#define N 64
typedef struct message{
    char buf[N];
    int len;
}msg_t;

pthread_mutex_t mymutex;

void* reverse_msgbuf(void* arg)
{
    msg_t *msg = (msg_t *)arg;
    int i = 0;
    char tmp;
    while(1)
    {
        pthread_mutex_lock(&mymutex);
        for(i = 0; i < msg->len/2; i ++)
        {
            tmp          = msg->buf[i];
            msg->buf[i]  = msg->buf[msg->len - i - 1];
            msg->buf[msg->len - i -1] = tmp;
        }
        pthread_mutex_unlock(&mymutex);
    }
}

void* printf_msgbuf(void* arg)
{
    msg_t *msg = (msg_t *)arg;
    while(1)
    {
        pthread_mutex_lock(&mymutex);
        printf("buf :%s\n",msg->buf);
        pthread_mutex_unlock(&mymutex);
        sleep(1);
    }
}

int main(int argc, const char *argv[])
{
    msg_t msg = {"123456789",9};

    pthread_t tid[2];
    pthread_mutex_init(&mymutex,NULL);

    pthread_create(&tid[0],NULL,reverse_msgbuf,(void *)&msg);
    pthread_create(&tid[1],NULL,printf_msgbuf,(void *)&msg);

    pause();

    return 0;
}