Linux Pthread 深入解析

Outline

- 1.线程特点

- 2.pthread创建

- 3.pthread终止

- 4.mutex互斥量使用框架

- 5.cond条件变量

- 6.综合实例

================================================================================================

1. 线程特点

线程拥有自己独立的栈、调度优先级和策略、信号屏蔽字（创建时继承）、errno变量以及线程私有数据。进程的其他地址空间均被所有线程所共享，因此线程可以访问程序的全局变量和堆中分配的数据，并通过同步机制保证对数据访问的一致性。

2. pthread创建

pthread有一个线程ID，类型为pthread_t，在使用printf打印时，应转换为u类型。

pthread_equal可用于比较两个id是否相等；pthread_self用于获取当前线程的ID。

pthread_create用于创建新的线程，可以给线程传入一个void *类型的参数，例如一个结构体指针或者一个数值。

系统并不能保证哪个线程会现运行：新创建的线程还是调用线程。

3. pthread终止

a) 从线程函数中返回

b) 被同一进程中的其他线程取消

c) 线程调用pthread_exit

注意，线程的返回值需要转换为void *类型。

pthread_exit(void *ret)

pthread_join(pthread_t id, void **ret)

ret均可设置为NULL

4. mutex 互斥量使用框架

pthread_mutex_t lock;

pthread_mutex_init 或者 PTHREAD_MUTEX_INITIALIZER（仅可用在静态变量）

pthread_mutex_lock / pthread_mutex_unlock / pthread_mutex_trylock

pthread_mutex_destroy

5. cond 条件变量

pthread_cond_t qready;

pthread_mutex_t qlock;

pthread_mutex_init 或者 PTHREAD_MUTEX_INITIALIZER

pthread_cond_init 或者 PTHREAD_COND_INITIALIZER

pthread_mutex_lock(&qlock...)

pthread_cond_wait(&qready, &qlock...) / pthread_cond_timewait

pthread_mutex_unlock(&qlock)
pthread_cond_destroy

//唤醒条件变量

pthread_cond_signal

pthread_cond_broadcast

条件变量是pthread中比较难以理解的一点，主要会产生以下疑惑：

Q1. 假如在调用pthread_{cond_wait | cond_timedwait}之前就调用pthread_cond_{signal | broadcast}会发生什么？

Q2. pthread_cond_{cond_wait | cond_timewait}为什么需要一个已经锁住的mutex作为变量？

Q3. pthread_cond_{signal | broadcast}使用之前必须获取wait中对应的mutex吗？

Q4. 假如pthread_cond_{signal | broadcast}必须获取mutex，那么下列两种形式，哪种正确？为什么？

1)

lock(lock_for_X);

change(X);

unlock(lock_for_X);

pthread_cond_{signal | broadcast};

2)

lock(lock_for_X);

change(X);

pthread_cond_{signal | broadcast};

unlock(lock_for_X);

----思考-------思考-------思考-------思考------思考-------思考------思考------思考-------思考-------

A1: 什么都不会发生，也不会出错，Linux系统中维持了一个cond_signal队列来暂存signal。

A2: 一般场景如下，我们需要检查某个条件是否满足（如队列X是否为空、布尔Y是否为真），假如没有条件变量，我们唯一的选择是

    while (1) {
      lock(lock_for_X);

      if (X is not empty) {
        unlock(lock_for_X);
        break;
      } else { //X is empty, loop continues
        unlock(lock_for_X);
        sleep(10);
      }
    }
    //X is not empty, loop ends
    process(X);

明显这种轮询的方式非常耗费CPU时间，这时候我们很容易的想到，如果有一种机制，可以异步通知我们队列的状态发生了变化，那么我们便无须再轮询，只要等到通知到来时再检查条件是否满足即可，其他时间则将程序休眠，因此现在代码变成这样：

    while (1) {
      lock(lock_for_X);
      if (X is not empty) {
        unlock(lock_for_X);
        break;
      } else {
        unlock(lock_for_X); //must called before my_wait(), otherwise no one can acquire the lock and make change to X
        -------------------------------------->窗口，由于已经解锁，其他程序可能改变X，并且试图唤醒mywait，但在一个繁忙的系统中，可能此时my_还没被调用！
        my_wait(); //go to sleep and wait for the notification
      }
    }

my_wait是一个假想的函数，作用如注释所示。

不难发现，这样做以后，我们无须再轮询了，只需要等待my_wait()被唤醒以后检查条件是否满足。

但是请注意，正如图中所示，存在1个时间窗口。若其他程序在这个窗口中试图唤醒my_wait，由于此时my_wait还没有被调用，那么这个信号将丢失，造成my_wait一直阻塞。解决的办法就是，要将unlock和my_wait合并成一个原子操作，这样就不会被其他程序插入执行。我想到这里，你应该已经明白了，这个原子操作的函数就是pthread_cond_{signal | broadcast}.

A3: 是的。

详见： http://stackoverflow.com/questions/4544234/calling-pthread-cond-signal-without-locking-mutex

A4: 对于1)，在不同的操作系统中，可能会造成不确定的调度结果（可能会造成调度优先级反转）；对于2）可以保证无论在何种操作系统中都将获得预期的调度顺序。

设想一个场景：有两个消费者线程A和B，我们设定A的优先级比B高，A正在等待条件变量被出发，即已经调用了pthread_wait，并且处于阻塞状态：

    lock(lock_for_X);
    while (X is empty) {
      pthread_cond_wait(&qready, &lock_for_X);
    }
    unlock(lock_for_X);

B中没有调用pthread_wait，而是做类似如下的处理：

    while(1) {
      lock(lock_for_X);
      dequeue(X);
      unlock(lock_for_X);
    }

另一个线程C，为生产者，采用1)方案，则代码如下，先unlock，再发出signal：

 lock(lock_for_X);
 change(X);
 unlock(lock_for_X);
 pthread_cond_{signal | broadcast};

当发出unlock以后，发送signal之前，此时消费者B已经满足了运行条件，而消费者A虽然优先级比B高，但是由于其运行条件还需要signal，所以不具备立刻运行的条件，此时就看操作系统如何实现调度算法了。有些操作系统，可能会因为A不具备立刻运行条件，即使它的优先级比B高，此时还是让B线程先运行，那么，后续将分成两种情况：

(a) B获得了lock，但是还没有将X队列中的刚刚加入的条目移除，此时C调用了signal，A接收到了signal，由于A的优先级高，那么A抢占B，A从函数pthread_cond_wait返回之前需要再次将lock上锁，但是A抢占后发现，lock被人锁住了（还没有被B释放），只好再次休眠，等待锁被释放，结果B又被唤醒，也可能因此造成A和B的死锁，这个具体要看操作系统的调度算法。

(b) B获得了lock，并且执行了dequeue，然后释放了锁。此时C调用了signal，A接收到了signal，由于A的优先级高，那么A抢占B，A这次顺利的获取了锁得以从pthread_cond_wait中返回，但是在检查条件时，却发现队列是空的，于是乎再次进入pthread_cond_wait休眠。结果A又无法被执行，A可能由此进入饥饿状态。

但是如果C采用2)方案：

 lock(lock_for_X);
 change(X);
 pthread_cond_{signal | broadcast};
 unlock(lock_for_X);

在unlock以后，A、B都具备了立即运行的条件，由于A比B的优先级高，因此操作系统必定会先调度A执行，就避免了前面一种不确定的调度结果。

主要参考： http://groups.google.com/group/comp.programming.threads/msg/a3721a2fc9b21c64?hl=ky

6. 综合实例

    /*
     * =====================================================================================
     *
     * Filename: pthread.c
     *
     * Description:
     *
     * Version: 1.0
     * Created: 08/17/11 11:06:35
     * Revision: none
     * Compiler: gcc
     *
     * Author: YOUR NAME (),
     * Company:
     *
     * =====================================================================================
     */
    #include <stdio.h>
    #include <pthread.h>
    #include <error.h>
    #include <stdlib.h>
    #include <unistd.h>
    #include <string.h>

    pthread_cond_t qready;
    pthread_mutex_t qlock = PTHREAD_MUTEX_INITIALIZER;

    struct foo {
        int cnt;
        pthread_mutex_t f_lock;
    };

    void cleanup(void *arg)
    {
        printf("clean up: %s\n", (char *)arg);
    }

    void printids(char *str)
    {
        printf("%s pid = %u tid = %u / 0x%x\n",
                str, (unsigned int)getpid(), (unsigned int)pthread_self(), (unsigned int)pthread_self());
    }

    void *thread1(void *arg)
    {
        pthread_mutex_lock(&qlock);
        pthread_cond_wait(&qready, &qlock);
        pthread_mutex_unlock(&qlock);

        printids("thread1:");
        
        pthread_cleanup_push(cleanup, "thread 1 first cleanup handler");
        pthread_cleanup_push(cleanup, "thread 1 second cleanup handler");
        printf("thread 1 push complete!\n");
        
        pthread_mutex_lock(&((struct foo *)arg)->f_lock);
        ((struct foo *)arg)->cnt ;
        printf("thread1: cnt = %d\n", ((struct foo *)arg)->cnt);
        pthread_mutex_unlock(&((struct foo *)arg)->f_lock);

        if (arg)
            return ((void *)0);
        
        pthread_cleanup_pop(0);
        pthread_cleanup_pop(0);

        pthread_exit((void *)1);
    }

    void *thread2(void *arg)
    {
        int exit_code = -1;
        printids("thread2:");
        
        printf("Now unlock thread1\n");

        pthread_mutex_lock(&qlock);
        pthread_mutex_unlock(&qlock);
        pthread_cond_signal(&qready);

        printf("Thread1 unlocked\n");

        pthread_cleanup_push(cleanup, "thread 2 first cleanup handler");
        pthread_cleanup_push(cleanup, "thread 2 second cleanup handler");
        printf("thread 2 push complete!\n");
        
        if (arg)
            pthread_exit((void *)exit_code);

        pthread_cleanup_pop(0);
        pthread_cleanup_pop(0);
        
        pthread_exit((void *)exit_code);
    }

    int main(int argc, char *argv[])
    {
        int ret;
        pthread_t tid1, tid2;
        void *retval;
        struct foo *fp;

        ret = pthread_cond_init(&qready, NULL);
        if (ret != 0) {
            printf("pthread_cond_init error: %s\n", strerror(ret));
            return -1;
        }



        if ((fp = malloc(sizeof(struct foo))) == NULL) {
            printf("malloc failed!\n");
            return -1;
        }

        if (pthread_mutex_init(&fp->f_lock, NULL) != 0) {
            free(fp);
            printf("init mutex failed!\n");
        }

        pthread_mutex_lock(&fp->f_lock);

        ret = pthread_create(&tid1, NULL, thread1, (void *)fp);
        if (ret != 0) {
            printf("main thread error: %s\n", strerror(ret));
            return -1;
        }
        ret = pthread_create(&tid2, NULL, thread2, (void *)1);
        if (ret != 0) {
            printf("main thread error: %s\n", strerror(ret));
            return -1;
        }

        
        ret = pthread_join(tid2, &retval);
        if (ret != 0) {
            printf("pthread join falied!\n");
            return -1;
        }
        else
            printf("thread2 exit code %d\n", (int)retval);

        fp->cnt = 1;
        printf("main thread: cnt = %d\n",fp->cnt);

        pthread_mutex_unlock(&fp->f_lock);

        sleep(1);    //there is no guarantee the main thread will run before the newly created thread, so we wait for a while
        printids("main thread:");

        printf("Press <RETURN> to exit\n");

        ret = pthread_cond_destroy(&qready);
        if (ret != 0) {
            printf("pthread_cond_destroy error: %s\n", strerror(ret));
            return -1;
        }

        getchar();
        return 0;
    }