Linux系统编程之线程二

一、互斥量

互斥量（mutex）从本质上来说是一把锁，在访问共享资源前对互斥量进行加锁，在访问完成后释放互斥量上的锁。对互斥量进行加锁后，任何其他试图再次对互斥量加锁的线程将会被阻塞直到当前线程释放该互斥锁。如果释放互斥锁时有多个线程阻塞，所有在该互斥锁上的阻塞线程都会变成可运行状态，第一个变为可运行状态的线程可以对互斥量加锁，其他线程将会看到互斥锁依然被锁住，只能回去等待它重新变为可用。在这种方式下，每次只有一个线程可以向前运行。

在设计时需要规定所有的线程必须遵守相同的数据访问规则。只有这样，互斥机制才能正常工作。操作系统并不会做数据访问的串行化。如果允许其中的某个线程在没有得到锁的情况下也可以访问共享资源，那么即使其它的线程在使用共享资源前都获取了锁，也还是会出现数据不一致的问题。

互斥变量用pthread_mutex_t数据类型表示。在使用互斥变量前必须对它进行初始化，可以把它置为常量PTHREAD_MUTEX_INITIALIZER（只对静态分配的互斥量），也可以通过调用pthread_mutex_init函数进行初始化。如果动态地分配互斥量（例如通过调用malloc函数），那么在释放内存前需要调用pthread_mutex_destroy。

二、互斥量运用

1.互斥量的创建和销毁

#include <pthread.h>
int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);
int pthread_mutex_destroy(pthread_mutex_t mutex);
// 返回：若成功返回0，否则返回错误编号

要用默认的属性初始化互斥量，只需把attr设置为NULL。

2. 加锁及解锁

#include <pthread.h>
int pthread_mutex_lock(pthread_mutex_t mutex);
int pthread_mutex_unlock(pthread_mutex_t mutex);
// 返回：若成功返回0，否则返回错误编号

pthread_mutex_lock是进行加锁，pthread_mutex_unlock是进行解锁的

3.互斥锁限制共享资源的访问

利用互斥锁可以在一个多线程程序中存在共享变量的情况下进行“上锁”，例如一个共享变量data，可以先在一个线程中第一利用互斥锁锁住，待该变量达到所需要求后，再进行放锁，这样一来，其他线程竞争锁或不竞争期间都是不可以对该变量进行操作的。
demo

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <stdlib.h>
int data = 0;
pthread_mutex_t mutex;
                                                                                                                                                                                                                   
void *func1(void* argc)
{
    printf("t1:%ld thread is creat\n",(unsigned long)pthread_self());//打印该线程的ＩＤ
    pthread_mutex_lock(&mutex);
    while(1){
        printf("t1:data=%d\n",data++);
        sleep(1);
        if(data == 3){
            pthread_mutex_unlock(&mutex);
            printf("t1 quit===============================\n");
            pthread_exit(NULL);
        }
    }
}

void *func2(void* argc)
{
    printf("t2:%ld thread is creat\n",(unsigned long)pthread_self());//打印该线程的ＩＤ
    while(1){
        printf("t2:data=%d\n",data);
        pthread_mutex_lock(&mutex);
        data++;
        pthread_mutex_unlock(&mutex);
        sleep(1);
    }
}

int main()
{
    pthread_t th1;
    pthread_t th2;
    int ret1;
    int ret2;
    pthread_mutex_init(&mutex,NULL);
    ret1 = pthread_create(&th1,NULL,&func1,NULL);
    if(ret1 == 0){
        printf("main:creat t1 seccess\n");
    }

    ret2 = pthread_create(&th2,NULL,&func2,NULL);
    if(ret2 == 0){
        printf("main:creat t2 seccess\n");
    }

    printf("main:%ld\n",(unsigned long)pthread_self());
    while(1){
        printf("main:data=%d\n",data);
        sleep(1);
    }
    pthread_join(th1,NULL);
    pthread_join(th2,NULL);

    pthread_mutex_destroy(&mutex);
    return 0;
}

三、避免死锁

如果线程试图对同一个互斥量加锁两次，那么它自身就会陷入死锁状态，但是使用互斥量时还有其他不太明显的方式也能产生死锁。例如，程序中使用一个以上的互斥量时，如果允许一个线程一直占用一个互斥量，并且在试图锁住第二个互斥量时处于阻塞状态，但是拥有第二个互斥量的线程也在试图锁住第一个互斥量。因为两个线程都在相互请求另一个线程拥有的资源，所以这两个线程都无法向前运行，于是就产生死锁。可以仔细控制互斥量加锁的顺序来避免死锁的发生。
demo

#include <stdio.h>                                                                                                                                                                                                                                                              
#include <pthread.h>
#include <unistd.h>
//造成死锁，有多把锁的情况下，线程之间为了竞争一把锁，而导致死锁
pthread_mutex_t mutex;
pthread_mutex_t mutex2;

void *func1(void* argc)
{
    pthread_mutex_lock(&mutex);
    sleep(1);
    pthread_mutex_lock(&mutex2);

    printf("t1:%ld thread is creat\n",(unsigned long)pthread_self());//打印该线程的ＩＤ
    printf("t1:param is %d\n",*((int*)argc));//先转换成整形指针，再取内容
    pthread_mutex_unlock(&mutex);
}

void *func2(void* argc)
{
    pthread_mutex_lock(&mutex2);
    sleep(1);
    pthread_mutex_lock(&mutex);

    printf("t2:%ld thread is creat\n",(unsigned long)pthread_self());//打印该线程的ＩＤ
    printf("t2:param is %d\n",*((int*)argc));//先转换成整形指针，再取内容
    pthread_mutex_unlock(&mutex);
}

void *func3(void* argc)
{
    pthread_mutex_lock(&mutex);
    printf("t3:%ld thread is creat\n",(unsigned long)pthread_self());//打印该线程的ＩＤ
    printf("t3:param is %d\n",*((int*)argc));//先转换成整形指针，再取内容
    pthread_mutex_unlock(&mutex);
}

int main()
{
    pthread_t th1;
    pthread_t th2;
    pthread_t th3;
    int param = 100;
    int ret1;
    int ret2;
    int ret3;
    pthread_mutex_init(&mutex,NULL);
    pthread_mutex_init(&mutex2,NULL);

    ret1 = pthread_create(&th1,NULL,&func1,(void*)(&param));
    if(ret1 == 0){
        printf("main:creat t1 seccess\n");
    }

    ret2 = pthread_create(&th2,NULL,&func2,(void*)(&param));
    if(ret2 == 0){
        printf("main:creat t2 seccess\n");
    }

    ret3 = pthread_create(&th3,NULL,&func3,(void*)(&param));
    if(ret3 == 0){
        printf("main:creat t3 seccess\n");
    }

    printf("main:%ld\n",(unsigned long)pthread_self());
    pthread_join(th1,NULL);
    pthread_join(th2,NULL);

    pthread_mutex_destroy(&mutex);
    pthread_mutex_destroy(&mutex2);
    return 0;
}