多线程锁

1. 背景知识：
多线程中经常需要使用到锁(pthread_mutex_t)来完成多个线程之间的某些同步操作
• 互斥锁：为了使不同线程互斥的使用某个资源
    ○ 锁的创建：pthread_mutex_init
        § pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
        § int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t * attr);
    ○ 锁的属性：
        pthread_mutexattr_init(pthread_mutexattr_t *mattr)
        pthread_mutexattr_settype(pthread_mutexattr_t *attr , int type)
        pthread_mutexattr_gettype(pthread_mutexattr_t *attr , int *type)
        § 普通锁：PTHREAD_MUTEX_TIMED_NP（当一个线程加锁以后，其余请求锁的线程将形成一个等待队列，并在解锁后按优先级获得锁。这种锁策略保证了资源分配的公平性）
        § 嵌套锁：PTHREAD_MUTEX_RECURSIVE_NP（允许同一个线程对同一个锁成功获得多次，并通过多次unlock解锁。如果是不同线程请求，则在加锁线程解锁时重新竞争）
        § 检错锁：PTHREAD_MUTEX_ERRORCHECK_NP（如果同一个线程请求同一个锁，则返回EDEADLK，否则与PTHREAD_MUTEX_TIMED_NP类型动作相同。这样就保证当不允许多次加锁时不会出现最简单情况下的死锁）
        § 适应锁：PTHREAD_MUTEX_ADAPTIVE_NP（动作最简单的锁类型，仅等待解锁后重新竞争）
    ○ 锁的释放：pthread_mutex_destory
    ○ 锁操作：
        § 加锁：int pthread_mutex_lock(pthread_mutex_t *mutex)
        § 解锁：int pthread_mutex_unlock(pthread_mutex_t *mutex)
        § 测试加锁：int pthread_mutex_trylock(pthread_mutex_t *mutex)
• 条件锁：为了保证不同线程之间有顺序（通过条件控制）地完成某个流程
    ○ 等待方式：
        § 无条件等待：pthread_cond_wait()
        § 计时等待：pthread_cond_timedwait()
    ○ 激活条件：
        §  int pthread_cond_signal(pthread_cond_t *cond); 激活一个等待该条件的线程，存在多个等待线程时按入队顺序激活其中一个
        § int pthread_cond_broadcast(pthread_cond_t *cond);  激活所有等待线程

互斥锁：

#include <pthread.h>
#include <stdio.h>
 
pthread_mutex_t mutex ;
void *print_msg(void *arg){
        int i=0;
        pthread_mutex_lock(&mutex);
        for(i=0;i<15;i++){
                printf("output : %d\n",i);
                usleep(100);
        }
        pthread_mutex_unlock(&mutex);
}
int main(int argc,char** argv){
        pthread_t id1;
        pthread_t id2;
        pthread_mutex_init(&mutex,NULL);
        pthread_create(&id1,NULL,print_msg,NULL);
        pthread_create(&id2,NULL,print_msg,NULL);
        pthread_join(id1,NULL);
        pthread_join(id2,NULL);
        pthread_mutex_destroy(&mutex);
        return 1;
}

条件锁：

//一个生产者消费者模型
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <pthread.h>
#include <unistd.h>

typedef struct node
{
    int num;
    struct node *next;
} node_t;

typedef node_t *list_t;
list_t head = NULL;
pthread_mutex_t mutex =
    PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond =
    PTHREAD_COND_INITIALIZER;

//消费者线程
void *consume(void *arg)
{
    node_t *tmp;
    while (1)
    {
        //加锁
        pthread_mutex_lock(&mutex); //对临界变量加锁
        if (head == NULL)           //如果头部指向空，等待
            pthread_cond_wait(&cond, &mutex);
        tmp = head;        //将要删除的节点赋值给中间值，然后头指针指向下一个
        head = head->next; //
        //解锁
        pthread_mutex_unlock(&mutex);
        //消费tmp节点
        printf("consum:%d\n", tmp->num);
        free(tmp);
        tmp = NULL;
        sleep(rand() % 5);
    }
}

//生产者线程
void *product(void *arg)
{ //函数的格式void *(*start_routine) (void *)，返回值是指针，参数也是
    node_t *n;
    while (1)
    {
        //生产一个新的节点
        n = (node_t *)malloc(sizeof(node_t));
        n->num = rand() % 1000 + 1;
        printf("p:%d\n", n->num);
        //加锁
        pthread_mutex_lock(&mutex);
        //将新节点放入到链表的头部
        n->next = head;
        head = n;
        //解锁
        pthread_mutex_unlock(&mutex);
        //通知消费者
        pthread_cond_signal(&cond);
        sleep(rand() % 5);
    }
}
int main(void)
{
    pthread_t pid, cid;
    //设置随机数的种子
    srand(time(NULL));
    //创建两个线程，用于生产者和消费者
    pthread_create(&pid, NULL, product, NULL); //创建线程后即执行该线程
    pthread_create(&cid, NULL, consume, NULL); //参数含义是（存放ID的缓存区，NULL缺省属性，线程的执行函数，函数的唯一参数）
    //等待线程的汇合
    pthread_join(pid, NULL);
    pthread_join(cid, NULL);
    //销毁mutex锁
    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond);
    return 0;
}