Linux互斥和同步应用程序（一）：posix线程和线程之间的相互排斥

    【版权声明：尊重原创，转载请保留出处：blog.csdn.net/shallnet 或 .../gentleliu，文章仅供学习交流。请勿用于商业用途】

    有了进程的概念，为何还要使用线程呢？

首先，回顾一下上一个系列我们讲到的IPC。各个进程之间具有独立的内存空间，要进行数据的传递仅仅能通过通信的方式进行，这样的方式不仅费时，并且非常不方便。

而同一个进程下的线程是共享全局内存的，所以一个线程的数据能够在还有一个线程中直接使用，及快捷又方便。

其次，在Linux系统下，启动一个新的进程必须分配给它独立的地址空间，建立众多的数据表来维护它的代码段、堆栈段和数据段，这是一种"昂贵"的多任务工作方式。而执行于一个进程中的多个线程，它们彼此之间使用同样的地址空间，共享大部分数据。启动一个线程所花费的空间远远小于启动一个进程所花费的空间。并且，线程间彼此切换所需的时间也远远小于进程间切换所须要的时间。

可是，伴随着这些长处，线程却带来了同步与相互排斥的问题。

以下先讲讲线程基本函数：

1. 线程的创建pthread_create

   #include <pthread.h>
   int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
                            void *(*start_routine) (void *), void *arg);

一个线程由一个线程ID（參数thread）标识，新的线程创建成功，其值通过指针thread返回。

參数attr为线程属性（比方：优先级、初始栈大小等），通常我们使用默认设置，设为NULL。

參数start_routine为一个函数指针，指向线程运行的函数，最后參数arg为函数start_routine唯一參数，假设须要传递多个參数。须要打包为结构。然后将其地址传给该函数。

pthread_create成功时返回0，失败为非0值，这和其它linux系统调用的习惯不一样。

2. pthread_join函数

   #include <pthread.h>
   int pthread_join(pthread_t thread, void **retval);

通过调用该函数等待一个给定线程终止，类似于线程的waitpid函数。

该函数等待參数thread指定的线程终止，该函数会堵塞，直到线程thread终止，将线程返回的(void *)指针赋值为retval指向的位置。然后回收已经终止线程占用的全部存储器资源。

 

3. pthread_self函数

   #include <pthread.h>
   pthread_t pthread_self(void);

                  该函数用于获取线程自身线程ID。

类似于进程的getpid函数。

4. pthread_detach函数

    	#include <pthread.h>
        	int pthread_detach(pthread_t thread);

该函数可分离可结合线程，线程能够通过以pthread_self()为參数的pthread_detach调用来分离他们自己。

一个分离线程是不能被其它线程回收或杀死的。他的存储器资源在他终止时由系统自己主动释放。一个可结合线程可以被其它线程收回其资源和杀死。在被其它线程收回之前，他的存储器资源是没有被释放的。在不论什么一个时间点上，线程是可结合的或者是可分离的。默认情况下，线程是被创建成可结合的。

为了避免存储器泄露。每一个可结合线程都应该要么被其它线程现实的收回，要么通过调用pthread_detach函数被分离。

在现实的程序中，我们一般都使用分离的线程。

5. pthread_exit函数

   #include <pthread.h>
   void pthread_exit(void *retval);

该函数作用就是终止线程。假设该线程未曾分离。他的线程ID和退出状态将一直保留到调用进程内某个其它线程对他调用pthread_join。

另外，当线程函数（pthread_create第三个參数）返回时，该线程将终止；当创建该线程的进程main函数返回时，该线程也将终止。

         以下给一个简单的演示样例：

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
 
void *func_th(void *arg)
{
    unsigned int     *val = (unsigned int *)arg;
 
    printf("=======%s->%d==thread%d: %u====\n", __func__, __LINE__,
            *val, (unsigned int)pthread_self());
    return NULL;
}
 
int main(int argc, const char *argv[])
{
    pthread_t   tid1, tid2;
    int         a, b;
 
    a = 1;
    if (0 != pthread_create(&tid1, NULL, func_th, &a)) {
        printf("pthread_create failed!\n");
        return -1;
    }
 
    b = 2;
    if (0 != pthread_create(&tid2, NULL, func_th, &b)) {
        printf("pthread_create failed!\n");
        return -1;
    }
 
 
    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
    return 0;
}
 

运行2次输出为：

# ./target_bin
=======func_th->9==thread1: 3077856064====
=======func_th->9==thread2: 3069463360====
# ./target_bin
=======func_th->9==thread2: 3069315904====
=======func_th->9==thread1: 3077708608====

类似于进程，线程的调度随机的。

在前面開始我们说到同一个进程内的线程是共享全局内存的。那么当多个线程同一时候去改动一个全局变量的时候就会出问题，假设一个线程在改动某个变量时中途被挂起，操作系统去调度另外一个线程运行，那就可能导致错误。

我们无法保证操作系统对这些操作都是原子的。

在我们在如今的样例中这样去复现这样的问题：一个线程对一个全局变量（100）进行读-加1-读操作，另个变量对该全局进行减1操作，我们通过sleep来实现加线程先运行。减线程在加线程的加和读之间进行，最后来查看加操作是否是我们期望的结果（101）。样例例如以下：

（该演示样例仅仅是为了强化执行时出错，并对这样的错误有一个宏观的了解而写）

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
 
int gval = 100;
 
void *func_add_th(void *arg)
{
    int     *val = (int *)arg;
 
    printf("==do %s==thread%d: %u====\n", __func__,
            *val, (unsigned int)pthread_self());
 
    printf("before add 1, gval=%d\n", gval);
    gval += 1;
 
    sleep(4);//此时add线程挂起。sub线程运行键操作
 
    printf("after add 1, gval=%d\n", gval);
    return NULL;
}
 
void *func_sub_th(void *arg)
{
    int     *val = (int *)arg;
 
    printf("==do %s==thread%d: %u====\n", __func__,
            *val, (unsigned int)pthread_self());
 
    gval -= 1;
 
    return NULL;
}
 
int main(int argc, const char *argv[])
{
    pthread_t   tid1, tid2;
    int         a, b;
 
    a = 1;
    if (0 != pthread_create(&tid1, NULL, func_add_th, &a)) {
        printf("pthread_create failed!\n");
        return -1;
    }
 
    sleep(1);  //保证add线程先被调度
    b = 2;
    if (0 != pthread_create(&tid2, NULL, func_sub_th, &b)) {
        printf("pthread_create failed!\n");
        return -1;
    }
 
 
    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
    return 0;
}

运行结果例如以下：

# ./target_bin
==do func_add_th==thread1: 3078355776====
before add 1, gval=100
==do func_sub_th==thread2: 3069963072====
after add 1, gval=100

通过输出我们能够看到sub操作在加1和读之间操作，终于读取出来的值仍然是100，不是我们期望的101。

这就是两个线程不是相互排斥带来的结果，所以我们希望在某某一线程一段代码执行期间，仅仅有一个线程在执行。当执行完毕之后，下一个线程执行该部分代码。所以我们须要将该部分代码加锁。这就是线程编程，也是并发编程须要考虑的问题。

解决多线程共享的问题就是使用相互排斥锁（mutex，即mutual exliusion）来保护共享数据。在运行某一段代码是首先要持有该相互排斥锁。运行完毕之后再释放该锁。相互排斥锁是类型为pthread_mutex_t的变量。

使用例如以下方法来加锁和解锁操作。

#include <pthread.h>
int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_trylock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);

首先我们须要初始化锁，初始化方法有两种，一种是静态初始化，给锁变量赋值PTHREAD_MUTEX_INITIALIZER，一种动态初始化，使用函数pthread_mutex_init。

我们使用静态方法初始化：

pthread_mutex_t     mutex = PTHREAD_MUTEX_INITIALIZER;

当试图使用pthread_mutex_lock（）获得一个已经被另外线程加锁的锁时。本线程将堵塞，直到相互排斥锁被解锁为止。

函数pthread_mutex_trylock为获取锁的非堵塞版本号，当获取失败时会马上返回。

我们改动add和sub线程函数分别例如以下：

void *func_add_th(void *arg)
{
    int     *val = (int *)arg;
 
    pthread_mutex_lock(&mutex);//此处加锁
    printf("==do %s==thread%d: %u====\n", __func__,
            *val, (unsigned int)pthread_self());
 
    printf("before add 1, gval=%d\n", gval);
    gval += 1;
 
    sleep(4);
 
    printf("after add 1, gval=%d\n", gval);
    pthread_mutex_unlock(&mutex);//此处释放锁
    return NULL;
}
void *func_sub_th(void *arg)
{
    int     *val = (int *)arg;
 
    pthread_mutex_lock(&mutex);
    printf("==do %s==thread%d: %u====\n", __func__,
            *val, (unsigned int)pthread_self());
 
    gval -= 1;
    pthread_mutex_unlock(&mutex);
 
    return NULL;
}

运行结果为：

# ./target_bin
==do func_add_th==thread1: 3077614400====
before add 1, gval=100
after add 1, gval=101
==do func_sub_th==thread2: 3069221696====

通过结果输出能够看到，sub操作是在add操作运行完毕之后才运行的。而add线程输出结果也是我们预期的。所以我们的加锁是成功的。

可是假设add线程要运行非常久的话。sub线程就要堵塞非常久。我们能够将sub线程加锁函数改为非堵塞版本号，当加锁失败时。马上返回。

改动后的sub线程函数：

void *func_sub_th(void *arg)
{
    int     *val = (int *)arg;
 
    if (0 != pthread_mutex_trylock(&mutex)) {
printf("failed to lock!\n");
        return NULL;
    }
    printf("==do %s==thread%d: %u====\n", __func__,
            *val, (unsigned int)pthread_self());
 
    gval -= 1;
    pthread_mutex_unlock(&mutex);
 
    return NULL;
}

执行输出为：

# ./target_bin
==do func_add_th==thread1: 3077638976====
before add 1, gval=100
failed to lock!
after add 1, gval=101

当多个线程同一时候须要多个同样锁时，可能会出现死锁的情况。比方两个线程同一时候须要相互排斥锁1和相互排斥锁2。线程a先获得锁1，线程b获得锁2，这是线程a、b分别还须要锁2和锁1。但此时两个锁都被加锁了，都堵塞在那里等待对方释放锁。这样死锁就出现了。我们来实现一下死锁的情况，将之前两个样例的线程函数改动例如以下：

pthread_mutex_t     mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t     mutex_sec = PTHREAD_MUTEX_INITIALIZER;
 
void *func_add_th(void *arg)
{
    int     *val = (int *)arg;
 
    pthread_mutex_lock(&mutex);//1. add线程先加第一个锁mutex
    printf("==do %s==thread%d: %u====\n", __func__,
            *val, (unsigned int)pthread_self());
    sleep(2);//等待2秒。让sub线程加第二个锁mutex_sec
    pthread_mutex_lock(&mutex_sec);//4. add线程加锁mutex_sec失败
 
    printf("before add 1, gval=%d\n", gval);
    gval += 1;
 
    sleep(4);
 
    printf("after add 1, gval=%d\n", gval);
    pthread_mutex_unlock(&mutex);
    pthread_mutex_unlock(&mutex_sec);
    return NULL;
}
 
void *func_sub_th(void *arg)
{
    int     *val = (int *)arg;
 
    pthread_mutex_lock(&mutex_sec);//2. Sub线程比add线程先加锁mutex_sec
    pthread_mutex_lock(&mutex);//3. Sub线程加锁mutex失败
 
    printf("==do %s==thread%d: %u====\n", __func__,
            *val, (unsigned int)pthread_self());
 
    gval -= 1;
    pthread_mutex_unlock(&mutex);
    pthread_mutex_unlock(&mutex_sec);
 
    return NULL;
}

上面两个线程依照函数凝视中1-2-3-4顺序执行。执行时程序就卡在那里出现了死锁。

能够使用非堵塞版本号的加锁函数来加锁，只是也要注意在第二个锁加锁不成功情况下，须要释放第一个锁再返回，不然其它线程仍然得不到第一个锁。有时在线程须要多个相互排斥锁时，让线程依照指定的相同顺序进行加锁也能够避免死锁。程序死锁出现时非常难定位，所以程序员在编程（尤其是在设计）时须要注意避免这个问题。

本节演示样例代码下载：

点击打开链接

版权声明：本文博主原创文章，博客，未经同意不得转载。

假设你认为你的实际物品，请点击以下“最佳”。