Unix高级环境编程系列笔记

通过这篇文字，您将能够解答如下问题：

• 如何来标识一个线程？

• 如何创建一个新线程？

• 如何实现单个线程的退出？

• 如何使调用线程阻塞等待指定线程的退出，并获得退出线程的返回码？

• 如何通过一个线程让另外一个线程退出？

• 如何实现线程退出时的清理动作？

• Unix系统如何实现线程之间的同步？

• 什么情况会发生线程死锁，如何避免死锁？

• 读写锁的使用方法。

• 什么是条件变量，它有什么作用？

• 如何使用条件变量？

1. 如何来标识一个线程？

表示进程号的为pid_t类型，表示线程号的是pthread_t类型。pthread_t是一个结构体而不是整型。

使用pthread_equal确定两个线程号是否相等：

#include int pthread_equal(pthread_t tid1, pthread_t tid2);Returns: nonzero if equal, 0 otherwise

使用pthread_self函数来获取线程的ID：

#include pthread_t pthread_self(void);Returns: the thread ID of the calling thread

2.如何创建一个新线程？

使用pthread_create函数创建一个新线程。

以下是代码片段： #include   int pthread_create(pthread_t *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void), void *restrict arg); Returns: 0 if OK, error number on failure

当该函数成功返回的时候，tidp所指向的内存位置将被分配给新创建的带有thread ID的线程。

attr用来定制各种线程参数。

新创建的线程将在start_rtn函数所指向的地址开始运行，该函数接受一个参数无类型的指针arg作为参数

线程创建时无法保证哪个线程会先运行。新创建的线程可以访问进程地址空间，并且继承了调用线程的浮点环境以及信号量掩码，但对于线程的未决信号量也将会被清除。

下面的这段程序创建新的线程，并打印线程id，新线程通过pthread_self函数获取自己的线程ID。

#include "apue.h"

#include pthread_t ntid;void printids(const char *s){    pid_t      pid;    pthread_t  tid;    pid = getpid();    tid = pthread_self();    printf("%s pid %u tid %u (0x%x)\\n", s, (unsigned int)pid,      (unsigned int)tid, (unsigned int)tid);}void * thr_fn(void *arg){    printids("new thread: ");    return((void *)0);}int main(void){    int     err;    err = pthread_create(&ntid, NULL, thr_fn, NULL);    if (err != 0)        err_quit("can\'t create thread: %s\\n", strerror(err));    printids("main thread:");    sleep(1);    exit(0);}

3. 如何实现单个线程的退出？

如果一个线程调用了exit, _Exit, 或者_exit，将导致整个进程的终止。要实现单个线程的退出，可以采用如下方式：

o 线程可以简单的从start routine返回，返回值就是线程的退出代码。

o 线程可以被同一进程中的其它线程终止。

o 线程调用pthread_exit

#include void pthread_exit(void *rval_ptr);

4.如何使调用线程阻塞等待指定线程的退出，并获得退出线程的返回码？

#include int pthread_join(pthread_t thread, void **rval_ptr);Returns: 0 if OK, error number on failure

调用线程将会被阻塞直到指定的线程终止。如果线程简单的从start routine返回则rval_ptr将包含返回代码。如果线程是被撤销(调用pthread_exit)的，rval_ptr指向的内存地址将被设置为PTHREAD_CANCELED.

通过调用pthread_join，我们自动的将一个线程变成分离状态，这样就可以实现资源的回收。如果线程已经处于分离状态，调用pthread_join将会失败，并返回EINVAL。

如果我们对于线程的返回值不感兴趣，可以将rval_ptr设置成NULL。

一段有缺陷的代码：

#include "apue.h"

#include struct foo {    int a, b, c, d;};voidprintfoo(const char *s, const struct foo *fp){    printf(s);    printf("  structure at 0x%x\\n", (unsigned)fp);    printf("  foo.a = %d\\n", fp->a);    printf("  foo.b = %d\\n", fp->b);    printf("  foo.c = %d\\n", fp->c);    printf("  foo.d = %d\\n", fp->d);}void *thr_fn1(void *arg){    struct foo  foo = {1, 2, 3, 4};    printfoo("thread 1:\\n", &foo);    pthread_exit((void *)&foo);}void *thr_fn2(void *arg){    printf("thread 2: ID is %d\\n", pthread_self());    pthread_exit((void *)0);}intmain(void){    int         err;    pthread_t   tid1, tid2;    struct foo  *fp;    err = pthread_create(&tid1, NULL, thr_fn1, NULL);    if (err != 0)        err_quit("can\'t create thread 1: %s\\n", strerror(err));    err = pthread_join(tid1, (void *)&fp);    if (err != 0)        err_quit("can\'t join with thread 1: %s\\n", strerror(err));    sleep(1);    printf("parent starting second thread\\n");    err = pthread_create(&tid2, NULL, thr_fn2, NULL);    if (err != 0)        err_quit("can\'t create thread 2: %s\\n", strerror(err));    sleep(1);    printfoo("parent:\\n", fp);    exit(0);}

注意，pthread_create 和 pthread_exit函数的无类型指针可以传递复杂的结构信息，但这个结构所使用的内存在调用者完成后必须仍然有效(分配在堆上或者是静态变量)，否则就会出现使用无效的错误。这段代码中thr_fn1函数中变量foo分配在栈上，但该线程退出后，主线程通过pthread_join获取foo的地址并进行操作(调用printfoo函数时)就会出现错误，因为此时thr_fn1已经退出它的栈已经被销毁。

5.如何通过一个线程让另外一个线程退出？

调用pthread_cancel函数将导致tid所指向的线程终止运行。但是，一个线程可以选择忽略其它线程控制该线程何时退出。注意，该函数并不等待线程终止，它仅仅提出要求。

#include int pthread_cancel(pthread_t tid);Returns: 0 if OK, error number on failure

6.如何实现线程退出时的清理动作？

线程可以建立多个清理处理程序，这些程序记录在栈中，也就是说他们的执行顺序与注册顺序想法。使用如下函数注册清理函数：

void pthread_cleanup_push(void (*rtn)(void *), void *arg);

void pthread_cleanup_pop(int execute);

rtn将被调用，并传以arg参数，引起该函数调用的情况如下：

o 调用pthread_exit

o 对于退出请求的反应

o 以非0参数调用pthread_cleanup_push

如果pthread_cleanup_pop的参数非0则仅仅移除该处理函数而不执行。

如果函数已经处于分离状态，则当它退出时线程底层的存储资源会被立即回收。处于分离状态的线程，如果调用pthread_join来等待其退出将会出现错误。

通过下列函数可以让进程处于分离状态：

#include int pthread_detach(pthread_t tid);Returns: 0 if OK, error number on failure

7.Unix系统如何实现线程之间的同步？

使用pthreads mutual-exclusion interfaces。引入了mutex，用pthread_mutex_t类型来表示。在使用这个变量之前，我们首先要将其初始化，或者赋值为PTHREAD_MUTEX_INITIALIZER(仅仅用于静态分配的mutexs)，或者调用pthread_mutex_init。如果我们动态的为mutex分配空间(例如通过调用malloc)，我们需要在调用free释放内存之前调用pthread_mutex_destroy。

函数定义如下：

以下是代码片段： #include   int pthread_mutex_init(pthread_mutex_t *restrict mutex,  const pthread_mutexattr_t *restrict attr); int pthread_mutex_destroy(pthread_mutex_t *mutex)； Both return: 0 if OK, error number on failure

初始化mutex时参数attr用来指定mutex的属性，要使用默认值将它设置为NULL。

使用如下函数对mutex进行加锁或解锁：

int pthread_mutex_lock(pthread_mutex_t *mutex);

int pthread_mutex_trylock(pthread_mutex_t *mutex);

int pthread_mutex_unlock(pthread_mutex_t *mutex);

All return: 0 if OK, error number on failure

注意当mutex已经被加锁则 pthread_mutex_lock会阻塞。如果一个线程无法忍受阻塞，可以调用pthread_mutex_trylock来加锁，加锁失败则立即返回EBUSY。

8.什么情况会发生线程死锁，如何避免死锁？

如果一个线程对mutex加两次锁则显然会导致死锁。但实际上死锁的情况要复杂的多：when we use more than one mutex in our programs, a deadlock can occur if we allow one thread to hold a mutex and block while trying to lock a second mutex at the same time that another thread holding the second mutex tries to lock the first mutex. Neither thread can proceed, because each needs a resource that is held by the other, so we have a deadlock.

死锁可以通过控制加锁的顺序来避免。有两个mutex A和B，如果所有的线程总是先对A加锁再对B加锁就不会产生死锁。但实际应用中可能很难保证这种顺序加锁的方式，这种情况下，可以使用pthread_mutex_trylock来避免死锁的发生。

9.读写锁的使用方法。

读写锁的初始化与销毁：

以下是代码片段： #include   int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock, const pthread_rwlockattr_t *restrict attr); int pthread_rwlock_destroy(pthread_rwlock_t *rwlock); Both return: 0 if OK, error number on failure

对于读写锁的初始化与销毁独占锁类似。

加锁与解锁：

#include int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);All return: 0 if OK, error number on failure

对于读者的数量会有限制，因此调用 pthread_rwlock_rdlock时需要检查返回值。

在正确使用的情况下，不需要检查pthread_rwlock_wrlock和pthread_rwlock_unlock的返回值。

条件加锁：

#include int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);Both return: 0 if OK, error number on failure

10.什么是条件变量，它有什么作用？

条件变量是线程可用的另外一种同步机制。条件变量给多个线程提供了一个会合的场所。条件变量与互斥量一起使用时，允许线程以无竞争的方式等待特定条件的发生。条件本身是由互斥量保护的。线程在改变状态前必须首先锁住互斥量，其它线程在获得互斥量之前不会觉察到这种变化。

11.如何使用条件变量？

条件变量的类型为pthread_cond_t ，其初始化与销毁的方式与mutex类似，注意静态变量可以通过指定常量PTHREAD_COND_INITIALIZER来进行初始化。

#include int pthread_cond_init(pthread_cond_t *restrict cond, pthread_condattr_t *restrict attr);int pthread_cond_destroy(pthread_cond_t *cond);Both return: 0 if OK, error number on failure

使用pthread_cond_wait来等待条件变成真。

函数定义如下：

调用者把锁住的mutex传递给pthread_cond_wait，函数把调用线程放到等待条件变量的线程列表上，然后对互斥量解锁，这两个操作是原子操作。这样就关闭了条件检查和线程进入休眠状态等待条件改变这两个操作之间的时间窗口。pthread_cond_wait返回时，mutex会再次被锁住。

注意，调用成功返回后，线程需要重新计算条件变量，因为其它线程可能已经改变了条件。

有两个函数用于通知线程一个条件已经被满足。pthread_cond_signal函数用来唤醒一个等待条件满足的线程， pthread_cond_broadcast用来唤醒所有等待条件满足的线程。

他们的定义为：

#include int pthread_cond_signal(pthread_cond_t *cond);int pthread_cond_broadcast(pthread_cond_t *cond);Both return: 0 if OK, error number on failure

下面的这段代码实现了类似于生产者消费者模型的程序，生产者通过enqueue_msg将消息放入队列，并发送信号通知给消费者线程。消费者线程被唤醒然后处理消息。

#include struct msg {    struct msg *m_next;    /* ... more stuff here ... */};struct msg *workq;pthread_cond_t qready = PTHREAD_COND_INITIALIZER;pthread_mutex_t qlock = PTHREAD_MUTEX_INITIALIZER;voidprocess_msg(void){    struct msg *mp;    for (;;) {        pthread_mutex_lock(&qlock);        while (workq == NULL)            pthread_cond_wait(&qready, &qlock); /*get msg from the queue*/        mp = workq;        workq = mp->m_next;        pthread_mutex_unlock(&qlock);        /* now process the message mp */    }}voidenqueue_msg(struct msg *mp){    pthread_mutex_lock(&qlock);    /*put msg in queue*/    mp->m_next = workq;    workq = mp;    pthread_mutex_unlock(&qlock);    pthread_cond_signal(&qready);}

在pthread_cond_signal发送消息之前并不需要占用锁，因为一旦线程被唤醒后通过while发现没有要处理的msg存在则会再次陷入睡眠。如果系统不能容忍这种竞争环境，则需要在unlock之前调用cond_signal，但是在多处理器机器上，这样会导致多线程被唤醒然后立即进入阻塞(cond_signal唤醒线程，但由于我们仍占用着锁，所以这些线程又会立即阻塞)。

Linux多线程编程详细解析----条件变量 pthread_cond_t

Linux操作系统下的多线程编程详细解析----条件变量

1.初始化条件变量pthread_cond_init

#include <pthread.h>

int pthread_cond_init(pthread_cond_t *cv,

const pthread_condattr_t *cattr);

返回值：函数成功返回0；任何其他返回值都表示错误

初始化一个条件变量。当参数cattr为空指针时，函数创建的是一个缺省的条件变量。否则条件变量的属性将由cattr中的属性值来决定。调用 pthread_cond_init函数时，参数cattr为空指针等价于cattr中的属性为缺省属性，只是前者不需要cattr所占用的内存开销。这个函数返回时，条件变量被存放在参数cv指向的内存中。

可以用宏PTHREAD_COND_INITIALIZER来初始化静态定义的条件变量，使其具有缺省属性。这和用pthread_cond_init函数动态分配的效果是一样的。初始化时不进行错误检查。如：

pthread_cond_t cv = PTHREAD_COND_INITIALIZER;

不能由多个线程同时初始化一个条件变量。当需要重新初始化或释放一个条件变量时，应用程序必须保证这个条件变量未被使用。

2.阻塞在条件变量上pthread_cond_wait

#include <pthread.h>

int pthread_cond_wait(pthread_cond_t *cv,

pthread_mutex_t *mutex);

返回值：函数成功返回0；任何其他返回值都表示错误

函数将解锁mutex参数指向的互斥锁，并使当前线程阻塞在cv参数指向的条件变量上。

被阻塞的线程可以被pthread_cond_signal函数，pthread_cond_broadcast函数唤醒，也可能在被信号中断后被唤醒。

pthread_cond_wait函数的返回并不意味着条件的值一定发生了变化，必须重新检查条件的值。

pthread_cond_wait函数返回时，相应的互斥锁将被当前线程锁定，即使是函数出错返回。

一般一个条件表达式都是在一个互斥锁的保护下被检查。当条件表达式未被满足时，线程将仍然阻塞在这个条件变量上。当另一个线程改变了条件的值并向条件变量发出信号时，等待在这个条件变量上的一个线程或所有线程被唤醒，接着都试图再次占有相应的互斥锁。

阻塞在条件变量上的线程被唤醒以后，直到pthread_cond_wait()函数返回之前条件的值都有可能发生变化。所以函数返回以后，在锁定相应的互斥锁之前，必须重新测试条件值。最好的测试方法是循环调用pthread_cond_wait函数，并把满足条件的表达式置为循环的终止条件。如：

pthread_mutex_lock();

while (condition_is_false)

pthread_cond_wait();

pthread_mutex_unlock();

阻塞在同一个条件变量上的不同线程被释放的次序是不一定的。

注意：pthread_cond_wait()函数是退出点，如果在调用这个函数时，已有一个挂起的退出请求，且线程允许退出，这个线程将被终止并开始执行善后处理函数，而这时和条件变量相关的互斥锁仍将处在锁定状态。

3.解除在条件变量上的阻塞pthread_cond_signal

#include <pthread.h>

int pthread_cond_signal(pthread_cond_t *cv);

返回值：函数成功返回0；任何其他返回值都表示错误

函数被用来释放被阻塞在指定条件变量上的一个线程。

必须在互斥锁的保护下使用相应的条件变量。否则对条件变量的解锁有可能发生在锁定条件变量之前，从而造成死锁。

唤醒阻塞在条件变量上的所有线程的顺序由调度策略决定，如果线程的调度策略是SCHED_OTHER类型的，系统将根据线程的优先级唤醒线程。

如果没有线程被阻塞在条件变量上，那么调用pthread_cond_signal()将没有作用。

4.阻塞直到指定时间pthread_cond_timedwait

#include <pthread.h>

#include <time.h>

int pthread_cond_timedwait(pthread_cond_t *cv,

pthread_mutex_t *mp, const structtimespec * abstime);

返回值：函数成功返回0；任何其他返回值都表示错误

函数到了一定的时间，即使条件未发生也会解除阻塞。这个时间由参数abstime指定。函数返回时，相应的互斥锁往往是锁定的，即使是函数出错返回。

注意：pthread_cond_timedwait函数也是退出点。

超时时间参数是指一天中的某个时刻。使用举例：

pthread_timestruc_t to;

to.tv_sec = time(NULL) + TIMEOUT;

to.tv_nsec = 0;

超时返回的错误码是ETIMEDOUT。

5.释放阻塞的所有线程pthread_cond_broadcast

#include <pthread.h>

int pthread_cond_broadcast(pthread_cond_t *cv);

返回值：函数成功返回0；任何其他返回值都表示错误

函数唤醒所有被pthread_cond_wait函数阻塞在某个条件变量上的线程，参数cv被用来指定这个条件变量。当没有线程阻塞在这个条件变量上时，pthread_cond_broadcast函数无效。

由于pthread_cond_broadcast函数唤醒所有阻塞在某个条件变量上的线程，这些线程被唤醒后将再次竞争相应的互斥锁，所以必须小心使用pthread_cond_broadcast函数。

6.释放条件变量pthread_cond_destroy

#include <pthread.h>

int pthread_cond_destroy(pthread_cond_t *cv);

返回值：函数成功返回0；任何其他返回值都表示错误

释放条件变量。

注意：条件变量占用的空间并未被释放。

7.唤醒丢失问题

在线程未获得相应的互斥锁时调用pthread_cond_signal或pthread_cond_broadcast函数可能会引起唤醒丢失问题。

唤醒丢失往往会在下面的情况下发生：

1. 一个线程调用pthread_cond_signal或pthread_cond_broadcast函数；
2. 另一个线程正处在测试条件变量和调用pthread_cond_wait函数之间；
3. 没有线程正在处在阻塞等待的状态下。

转载声明： 本文转自 http://pzs1237.blog.163.com/blog/static/29813006200952335454934/

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

条件锁pthread_cond_t

说明，
等待线程
1。使用pthread_cond_wait前要先加锁
2。pthread_cond_wait内部会解锁，然后等待条件变量被其它线程激活
3。pthread_cond_wait被激活后会再自动加锁

激活线程：
1。加锁（和等待线程用同一个锁）
2。pthread_cond_signal发送信号
3。解锁
激活线程的上面三个操作在运行时间上都在等待线程的pthread_cond_wait函数内部。

程序示例：

运行结果：

[work@db-testing-com06-vm3.db01.baidu.com pthread]$ gcc -o pthread_cond pthread_cond.c -lpthread
[work@db-testing-com06-vm3.db01.baidu.com pthread]$ ./pthread_cond 
decrement_count get count_lock
decrement_count count == 0 
decrement_count before cond_wait 
increment_count get count_lock 
increment_count before cond_signal 
increment_count after cond_signal 
decrement_count after cond_wait

转载声明： 本文转自 http://egeho123.blogbus.com/logs/10821816.html

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

多线程编程,条件变量pthread_cond_t应用

程序代码：

运行结果：
[work@db-testing-com06-vm3.db01.baidu.com pthread]$ gcc -o pthread_cond2 pthread_cond2.c -lpthread
[work@db-testing-com06-vm3.db01.baidu.com pthread]$ ./pthread_cond2                               
counter: 0
counter: 0
counter: 1
counter: 2
counter: 3
counter: 4
counter: 5
counter: 6
counter: 7
counter: 8
counter: 9

调试程序的运行过程：

 注：更清晰的运行流程请详见如下“改进代码”

条件变量函数

初始化条件变量

使用 pthread_cond_init(3C) 可以将 cv 所指示的条件变量初始化为其缺省值，或者指定已经使用 pthread_condattr_init() 设置的条件变量属性。

pthread_cond_init 语法

int pthread_cond_init(pthread_cond_t *cv,

    const pthread_condattr_t *cattr);

#include <pthread.h>

pthread_cond_t cv;

pthread_condattr_t cattr;

int ret;

/* initialize a condition variable to its default value */

ret = pthread_cond_init(&cv, NULL);

/* initialize a condition variable */

ret = pthread_cond_init(&cv, &cattr);

cattr 设置为 NULL。将 cattr 设置为 NULL 与传递缺省条件变量属性对象的地址等效，但是没有内存开销。对于 Solaris 线程，请参见cond_init 语法。

使用 PTHREAD_COND_INITIALIZER 宏可以将以静态方式定义的条件变量初始化为其缺省属性。PTHREAD_COND_INITIALIZER 宏与动态分配具有 null 属性的 pthread_cond_init() 等效，但是不进行错误检查。

多个线程决不能同时初始化或重新初始化同一个条件变量。如果要重新初始化或销毁某个条件变量，则应用程序必须确保该条件变量未被使用。

pthread_cond_init 返回值

pthread_cond_init() 在成功完成之后会返回零。其他任何返回值都表示出现了错误。如果出现以下任一情况，该函数将失败并返回对应的值。

EINVAL

描述:

cattr 指定的值无效。

EBUSY

描述:

条件变量处于使用状态。

EAGAIN

描述:

必要的资源不可用。

ENOMEM

描述:

内存不足，无法初始化条件变量。

基于条件变量阻塞

使用 pthread_cond_wait(3C) 可以以原子方式释放 mp 所指向的互斥锁，并导致调用线程基于 cv 所指向的条件变量阻塞。对于 Solaris 线程，请参见cond_wait 语法。

pthread_cond_wait 语法

int pthread_cond_wait(pthread_cond_t *cv,pthread_mutex_t *mutex);

#include <pthread.h>

pthread_cond_t cv;

pthread_mutex_t mp;

int ret;

/* wait on condition variable */

ret = pthread_cond_wait(&cv, &mp);

阻塞的线程可以通过 pthread_cond_signal() 或 pthread_cond_broadcast() 唤醒，也可以在信号传送将其中断时唤醒。

不能通过 pthread_cond_wait() 的返回值来推断与条件变量相关联的条件的值的任何变化。必须重新评估此类条件。

pthread_cond_wait() 例程每次返回结果时调用线程都会锁定并且拥有互斥锁，即使返回错误时也是如此。

该条件获得信号之前，该函数一直被阻塞。该函数会在被阻塞之前以原子方式释放相关的互斥锁，并在返回之前以原子方式再次获取该互斥锁。

通常，对条件表达式的评估是在互斥锁的保护下进行的。如果条件表达式为假，线程会基于条件变量阻塞。然后，当该线程更改条件值时，另一个线程会针对条件变量发出信号。这种变化会导致所有等待该条件的线程解除阻塞并尝试再次获取互斥锁。

必须重新测试导致等待的条件，然后才能从 pthread_cond_wait() 处继续执行。唤醒的线程重新获取互斥锁并从 pthread_cond_wait() 返回之前，条件可能会发生变化。等待线程可能并未真正唤醒。建议使用的测试方法是，将条件检查编写为调用 pthread_cond_wait() 的 while() 循环。

pthread_mutex_lock();

        while(condition_is_false)

            pthread_cond_wait();

    pthread_mutex_unlock();

如果有多个线程基于该条件变量阻塞，则无法保证按特定的顺序获取互斥锁。

注 –

pthread_cond_wait() 是取消点。如果取消处于暂挂状态，并且调用线程启用了取消功能，则该线程会终止，并在继续持有该锁的情况下开始执行清除处理程序。

pthread_cond_wait 返回值

pthread_cond_wait() 在成功完成之后会返回零。其他任何返回值都表示出现了错误。如果出现以下情况，该函数将失败并返回对应的值。

EINVAL

描述:

cv 或 mp 指定的值无效。

解除阻塞一个线程

对于基于 cv 所指向的条件变量阻塞的线程，使用 pthread_cond_signal(3C) 可以解除阻塞该线程。对于 Solaris 线程，请参见cond_signal 语法。

pthread_cond_signal 语法

int pthread_cond_signal(pthread_cond_t *cv);

#include <pthread.h>

pthread_cond_t cv;

int ret;

/* one condition variable is signaled */

ret = pthread_cond_signal(&cv);

应在互斥锁的保护下修改相关条件，该互斥锁用于获得信号的条件变量中。否则，可能在条件变量的测试和 pthread_cond_wait() 阻塞之间修改该变量，这会导致无限期等待。

调度策略可确定唤醒阻塞线程的顺序。对于 SCHED_OTHER，将按优先级顺序唤醒线程。

如果没有任何线程基于条件变量阻塞，则调用 pthread_cond_signal() 不起作用。

示例 4–8 使用 pthread_cond_wait() 和 pthread_cond_signal()

pthread_mutex_t count_lock;

pthread_cond_t count_nonzero;

unsigned count;

decrement_count()

{

    pthread_mutex_lock(&count_lock);

    while (count == 0)

        pthread_cond_wait(&count_nonzero, &count_lock);

    count = count - 1;

    pthread_mutex_unlock(&count_lock);

}

increment_count()

{

    pthread_mutex_lock(&count_lock);

    if (count == 0)

        pthread_cond_signal(&count_nonzero);

    count = count + 1;

    pthread_mutex_unlock(&count_lock);

}

pthread_cond_signal 返回值

pthread_cond_signal() 在成功完成之后会返回零。其他任何返回值都表示出现了错误。如果出现以下情况，该函数将失败并返回对应的值。

EINVAL

描述:

cv 指向的地址非法。

说明了如何使用 pthread_cond_wait() 和 pthread_cond_signal()。

在指定的时间之前阻塞

pthread_cond_timedwait(3C) 的用法与 pthread_cond_wait() 的用法基本相同，区别在于在由 abstime 指定的时间之后 pthread_cond_timedwait() 不再被阻塞。

pthread_cond_timedwait 语法

int pthread_cond_timedwait(pthread_cond_t *cv,

    pthread_mutex_t *mp, const struct timespec *abstime);

#include <pthread.h>

#include <time.h>

pthread_cond_t cv;

pthread_mutex_t mp;

timestruct_t abstime;

int ret;

/* wait on condition variable */

ret = pthread_cond_timedwait(&cv, &mp, &abstime);

pthread_cond_timewait() 每次返回时调用线程都会锁定并且拥有互斥锁，即使 pthread_cond_timedwait() 返回错误时也是如此。 对于 Solaris 线程

pthread_cond_timedwait() 函数会一直阻塞，直到该条件获得信号，或者最后一个参数所指定的时间已过为止。

注 –

pthread_cond_timedwait() 也是取消点。

示例 4–9 计时条件等待

pthread_timestruc_t to;

pthread_mutex_t m;

pthread_cond_t c;

...

pthread_mutex_lock(&m);

to.tv_sec = time(NULL) + TIMEOUT;

to.tv_nsec = 0;

while (cond == FALSE) {

    err = pthread_cond_timedwait(&c, &m, &to);

    if (err == ETIMEDOUT) {

        /* timeout, do something */

        break;

    }

}

pthread_mutex_unlock(&m);

pthread_cond_timedwait 返回值

pthread_cond_timedwait() 在成功完成之后会返回零。其他任何返回值都表示出现了错误。如果出现以下任一情况，该函数将失败并返回对应的值。

EINVAL

描述:

cv 或 abstime 指向的地址非法。

ETIMEDOUT

描述:

abstime 指定的时间已过。

超时会指定为当天时间，以便在不重新计算值的情况下高效地重新测试条件，如示例 4–9 中所示。

在指定的时间间隔内阻塞

pthread_cond_reltimedwait_np(3C) 的用法与 pthread_cond_timedwait() 的用法基本相同，唯一的区别在于 pthread_cond_reltimedwait_np() 会采用相对时间间隔而不是将来的绝对时间作为其最后一个参数的值。

pthread_cond_reltimedwait_np 语法

int  pthread_cond_reltimedwait_np(pthread_cond_t *cv, 

    pthread_mutex_t *mp, 

   const struct timespec *reltime);

#include <pthread.h>

#include <time.h>

pthread_cond_t cv;

pthread_mutex_t mp;

timestruct_t reltime;

int ret;

/* wait on condition variable */

ret = pthread_cond_reltimedwait_np(&cv, &mp, &reltime);

pthread_cond_reltimedwait_np() 每次返回时调用线程都会锁定并且拥有互斥锁，即使 pthread_cond_reltimedwait_np() 返回错误时也是如此。对于 Solaris 线程，请参见 cond_reltimedwait(3C)。pthread_cond_reltimedwait_np() 函数会一直阻塞，直到该条件获得信号，或者最后一个参数指定的时间间隔已过为止。

注 –

pthread_cond_reltimedwait_np() 也是取消点。

pthread_cond_reltimedwait_np 返回值

pthread_cond_reltimedwait_np() 在成功完成之后会返回零。其他任何返回值都表示出现了错误。如果出现以下任一情况，该函数将失败并返回对应的值。

EINVAL

描述:

cv 或 reltime 指示的地址非法。

ETIMEDOUT

描述:

reltime 指定的时间间隔已过。

解除阻塞所有线程

对于基于 cv 所指向的条件变量阻塞的线程，使用 pthread_cond_broadcast(3C) 可以解除阻塞所有这些线程，这由 pthread_cond_wait() 来指定。

pthread_cond_broadcast 语法

int pthread_cond_broadcast(pthread_cond_t *cv);

#include <pthread.h>

pthread_cond_t cv;

int ret;

/* all condition variables are signaled */

ret = pthread_cond_broadcast(&cv);

如果没有任何线程基于该条件变量阻塞，则调用 pthread_cond_broadcast() 不起作用。对于 Solaris 线程，请参见cond_broadcast 语法。

由于 pthread_cond_broadcast() 会导致所有基于该条件阻塞的线程再次争用互斥锁，因此请谨慎使用 pthread_cond_broadcast()。例如，通过使用pthread_cond_broadcast()，线程可在资源释放后争用不同的资源量，如示例 4–10 中所示。

示例 4–10 条件变量广播

pthread_mutex_t rsrc_lock;

pthread_cond_t rsrc_add;

unsigned int resources;

get_resources(int amount)

{

    pthread_mutex_lock(&rsrc_lock);

    while (resources < amount) {

        pthread_cond_wait(&rsrc_add, &rsrc_lock);

    }

    resources -= amount;

    pthread_mutex_unlock(&rsrc_lock);

}

add_resources(int amount)

{

    pthread_mutex_lock(&rsrc_lock);

    resources += amount;

    pthread_cond_broadcast(&rsrc_add);

    pthread_mutex_unlock(&rsrc_lock);

}

请注意，在 add_resources() 中，首先更新 resources 还是首先在互斥锁中调用 pthread_cond_broadcast() 无关紧要。

应在互斥锁的保护下修改相关条件，该互斥锁用于获得信号的条件变量中。否则，可能在条件变量的测试和 pthread_cond_wait() 阻塞之间修改该变量，这会导致无限期等待。

pthread_cond_broadcast 返回值

pthread_cond_broadcast() 在成功完成之后会返回零。其他任何返回值都表示出现了错误。如果出现以下情况，该函数将失败并返回对应的值。

EINVAL

描述:

cv 指示的地址非法。

销毁条件变量状态

使用 pthread_cond_destroy(3C) 可以销毁与 cv 所指向的条件变量相关联的任何状态。对于 Solaris 线程，请参见cond_destroy 语法。

pthread_cond_destroy 语法

int pthread_cond_destroy(pthread_cond_t *cv);

#include <pthread.h>

pthread_cond_t cv;

int ret;

/* Condition variable is destroyed */

ret = pthread_cond_destroy(&cv);

请注意，没有释放用来存储条件变量的空间。

pthread_cond_destroy 返回值

pthread_cond_destroy() 在成功完成之后会返回零。其他任何返回值都表示出现了错误。如果出现以下情况，该函数将失败并返回对应的值。

EINVAL

描述:

cv 指定的值无效。

注意:pthread_cond_destroy 销毁一个条件变量，释放它拥有的资源。进入 pthread_cond_destroy 之前，必须没有在该条件变量上等待的线程。
Attempting to destroy a condition variable upon which other threads are currently blocked results in undefined behavior.

唤醒丢失问题

如果线程未持有与条件相关联的互斥锁，则调用 pthread_cond_signal() 或 pthread_cond_broadcast() 会产生唤醒丢失错误。

满足以下所有条件时，即会出现唤醒丢失问题：

• 一个线程调用 pthread_cond_signal() 或 pthread_cond_broadcast()

• 另一个线程已经测试了该条件，但是尚未调用 pthread_cond_wait()

• 没有正在等待的线程

  信号不起作用，因此将会丢失

仅当修改所测试的条件但未持有与之相关联的互斥锁时，才会出现此问题。只要仅在持有关联的互斥锁同时修改所测试的条件，即可调用 pthread_cond_signal() 和pthread_cond_broadcast()，而无论这些函数是否持有关联的互斥锁。

生成方和使用者问题

并发编程中收集了许多标准的众所周知的问题，生成方和使用者问题只是其中的一个问题。此问题涉及到一个大小限定的缓冲区和两类线程（生成方和使用者），生成方将项放入缓冲区中，然后使用者从缓冲区中取走项。

生成方必须在缓冲区中有可用空间之后才能向其中放置内容。使用者必须在生成方向缓冲区中写入之后才能从中提取内容。

条件变量表示一个等待某个条件获得信号的线程队列。

示例 4–11 中包含两个此类队列。一个队列 (less) 针对生成方，用于等待缓冲区中出现空位置。另一个队列 (more) 针对使用者，用于等待从缓冲槽位的空位置中提取其中包含的信息。该示例中还包含一个互斥锁，因为描述该缓冲区的数据结构一次只能由一个线程访问。

示例 4–11 生成方和使用者的条件变量问题

typedef struct {

    char buf[BSIZE];

    int occupied;

    int nextin;

    int nextout;

    pthread_mutex_t mutex;

    pthread_cond_t more;

    pthread_cond_t less;

} buffer_t;

buffer_t buffer;

如示例 4–12 中所示，生成方线程获取该互斥锁以保护 buffer 数据结构，然后，缓冲区确定是否有空间可用于存放所生成的项。如果没有可用空间，生成方线程会调用pthread_cond_wait()。pthread_cond_wait() 会导致生成方线程连接正在等待 less 条件获得信号的线程队列。less 表示缓冲区中的可用空间。

与此同时，在调用 pthread_cond_wait() 的过程中，该线程会释放互斥锁的锁定。正在等待的生成方线程依赖于使用者线程在条件为真时发出信号，如示例 4–12 中所示。该条件获得信号时，将会唤醒等待 less 的第一个线程。但是，该线程必须再次锁定互斥锁，然后才能从 pthread_cond_wait() 返回。

获取互斥锁可确保该线程再次以独占方式访问缓冲区的数据结构。该线程随后必须检查缓冲区中是否确实存在可用空间。如果空间可用，该线程会向下一个可用的空位置中进行写入。

与此同时，使用者线程可能正在等待项出现在缓冲区中。这些线程正在等待条件变量 more。刚在缓冲区中存储内容的生成方线程会调用 pthread_cond_signal() 以唤醒下一个正在等待的使用者。如果没有正在等待的使用者，此调用将不起作用。

最后，生成方线程会解除锁定互斥锁，从而允许其他线程处理缓冲区的数据结构。

示例 4–12 生成方和使用者问题：生成方

void producer(buffer_t *b, char item)

{

    pthread_mutex_lock(&b->mutex);

   

    while (b->occupied >= BSIZE)

        pthread_cond_wait(&b->less, &b->mutex);

    assert(b->occupied < BSIZE);

    b->buf[b->nextin++] = item;

    b->nextin %= BSIZE;

    b->occupied++;

    /* now: either b->occupied < BSIZE and b->nextin is the index

       of the next empty slot in the buffer, or

       b->occupied == BSIZE and b->nextin is the index of the

       next (occupied) slot that will be emptied by a consumer

       (such as b->nextin == b->nextout) */

    pthread_cond_signal(&b->more);

    pthread_mutex_unlock(&b->mutex);

}

请注意 assert() 语句的用法。除非在编译代码时定义了 NDEBUG，否则 assert() 在其参数的计算结果为真（非零）时将不执行任何操作。如果参数的计算结果为假（零），则该程序会中止。在多线程程序中，此类断言特别有用。如果断言失败，assert() 会立即指出运行时问题。assert() 还有另一个作用，即提供有用的注释。

以 /* now: either b->occupied ... 开头的注释最好以断言形式表示，但是由于语句过于复杂，无法用布尔值表达式来表示，因此将用英语表示。

断言和注释都是不变量的示例。这些不变量是逻辑语句，在程序正常执行时不应将其声明为假，除非是线程正在修改不变量中提到的一些程序变量时的短暂修改过程中。当然，只要有线程执行语句，断言就应当为真。

使用不变量是一种极为有用的方法。即使没有在程序文本中声明不变量，在分析程序时也应将其视为不变量。

每次线程执行包含注释的代码时，生成方代码中表示为注释的不变量始终为真。如果将此注释移到紧挨 mutex_unlock() 的后面，则注释不一定仍然为真。如果将此注释移到紧跟assert() 之后的位置，则注释仍然为真。

因此，不变量可用于表示一个始终为真的属性，除非一个生成方或一个使用者正在更改缓冲区的状态。线程在互斥锁的保护下处理缓冲区时，该线程可能会暂时声明不变量为假。但是，一旦线程结束对缓冲区的操作，不变量即会恢复为真。

示例 4–13 给出了使用者的代码。该逻辑流程与生成方的逻辑流程相对称。

示例 4–13 生成方和使用者问题：使用者

char consumer(buffer_t *b)

{

    char item;

    pthread_mutex_lock(&b->mutex);

    while(b->occupied <= 0)

        pthread_cond_wait(&b->more, &b->mutex);

    assert(b->occupied > 0);

    item = b->buf[b->nextout++];

    b->nextout %= BSIZE;

    b->occupied--;

    /* now: either b->occupied > 0 and b->nextout is the index

       of the next occupied slot in the buffer, or

       b->occupied == 0 and b->nextout is the index of the next

       (empty) slot that will be filled by a producer (such as

       b->nextout == b->nextin) */

    pthread_cond_signal(&b->less);

    pthread_mutex_unlock(&b->mutex);

    return(item);

}

线程的分离状态 pthread_attr_setdetachstate 函数使用

在任何一个时间点上，线程是可结合的（joinable），或者是分离的（detached）。一个可结合的线程能够被其他线程收回其资源和杀死；在被其他线程回收之前，它的存储器资源（如栈）是不释放的。相反，一个分离的线程是不能被其他线程回收或杀死的，它的存储器资源在它终止时由系统自动释放。

        线程的分离状态决定一个线程以什么样的方式来终止自己。在默认情况下线程是非分离状态的，这种情况下，原有的线程等待创建的线程结束。只有当pthread_join（）函数返回时，创建的线程才算终止，才能释放自己占用的系统资源。而分离线程不是这样子的，它没有被其他的线程所等待，自己运行结束了，线程也就终止了，马上释放系统资源。程序员应该根据自己的需要，选择适当的分离状态。所以如果我们在创建线程时就知道不需要了解线程的终止状态，则可以pthread_attr_t结构中的detachstate线程属性，让线程以分离状态启动。

设置线程分离状态的函数为pthread_attr_setdetachstate（pthread_attr_t *attr, int detachstate）。第二个参数可选为PTHREAD_CREATE_DETACHED（分离线程）和 PTHREAD _CREATE_JOINABLE（非分离线程）。这里要注意的一点是，如果设置一个线程为分离线程，而这个线程运行又非常快，它很可能在pthread_create函数返回之前就终止了，它终止以后就可能将线程号和系统资源移交给其他的线程使用，这样调用pthread_create的线程就得到了错误的线程号。要避免这种情况可以采取一定的同步措施，最简单的方法之一是可以在被创建的线程里调用pthread_cond_timewait函数，让这个线程等待一会儿，留出足够的时间让函数pthread_create返回。设置一段等待时间，是在多线程编程里常用的方法。但是注意不要使用诸如wait（）之类的函数，它们是使整个进程睡眠，并不能解决线程同步的问题。

另外一个可能常用的属性是线程的优先级，它存放在结构sched_param中。用函数pthread_attr_getschedparam和函数pthread_attr_setschedparam进行存放，一般说来，我们总是先取优先级，对取得的值修改后再存放回去。

线程等待——正确处理线程终止

#include <pthread.h>

void pthread_exit(void *retval);

void pthread_join(pthread_t th,void *thread_return);//挂起等待th结束,*thread_return=retval;

int pthread_detach(pthread_t th);

如果线程处于joinable状态，则只能只能被创建他的线程等待终止。

在Linux平台默认情况下，虽然各个线程之间是相互独立的，一个线程的终止不会去通知或影响其他的线程。但是已经终止的线程的资源并不会随着线程的终止而得到释放，我们需要调用 pthread_join() 来获得另一个线程的终止状态并且释放该线程所占的资源。（说明：线程处于joinable状态下）

调用该函数的线程将挂起，等待 th 所表示的线程的结束。 thread_return 是指向线程 th 返回值的指针。需要注意的是 th 所表示的线程必须是 joinable 的，即处于非 detached（游离）状态；并且只可以有唯一的一个线程对 th 调用 pthread_join() 。如果 th 处于 detached 状态，那么对 th 的 pthread_join() 调用将返回错误。

如果不关心一个线程的结束状态，那么也可以将一个线程设置为 detached 状态，从而让操作系统在该线程结束时来回收它所占的资源。将一个线程设置为detached 状态可以通过两种方式来实现。一种是调用 pthread_detach() 函数，可以将线程 th 设置为 detached 状态。另一种方法是在创建线程时就将它设置为 detached 状态，首先初始化一个线程属性变量，然后将其设置为 detached 状态，最后将它作为参数传入线程创建函数 pthread_create()，这样所创建出来的线程就直接处于 detached 状态。

创建 detach 线程：

pthread_t tid;

pthread_attr_t attr;

pthread_attr_init(&attr);

pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);

pthread_create(&tid, &attr, THREAD_FUNCTION, arg);

总之为了在使用 pthread 时避免线程的资源在线程结束时不能得到正确释放，从而避免产生潜在的内存泄漏问题，在对待线程结束时，要确保该线程处于 detached 状态，否着就需要调用 pthread_join() 函数来对其进行资源回收。

linux c学习笔记----消息队列（ftok,msgget，msgsnd，msgrcv，msgctl）

博客分类： 
• Unix/linux
• c/c++

 例子：

server.c

 client.c

1.Linux“线程”

     进程与线程之间是有区别的，不过Linux内核只提供了轻量进程的支持，未实现线程模型。Linux是一种“多进程单线程”的操作系统。Linux本身只有进程的概念，而其所谓的“线程”本质上在内核里仍然是进程。

     大家知道，进程是资源分配的单位，同一进程中的多个线程共享该进程的资源（如作为共享内存的全局变量）。Linux中所谓的“线程”只是在被创建时clone了父进程的资源，因此clone出来的进程表现为“线程”，这一点一定要弄清楚。因此，Linux“线程”这个概念只有在打冒号的情况下才是最准确的。

     目前Linux中最流行的线程机制为LinuxThreads，所采用的就是线程－进程“一对一”模型，调度交给核心，而在用户级实现一个包括信号处理在内的线程管理机制。LinuxThreads由Xavier Leroy (Xavier.Leroy@inria.fr)负责开发完成，并已绑定在GLIBC中发行，它实现了一种BiCapitalized面向Linux的Posix 1003.1c “pthread”标准接口。Linuxthread可以支持Intel、Alpha、MIPS等平台上的多处理器系统。

　　按照POSIX 1003.1c 标准编写的程序与Linuxthread 库相链接即可支持Linux平台上的多线程，在程序中需包含头文件pthread. h，在编译链接时使用命令：

　　其中-REENTRANT宏使得相关库函数(如stdio.h、errno.h中函数) 是可重入的、线程安全的(thread-safe)，-lpthread则意味着链接库目录下的libpthread.a或libpthread.so文件。使用Linuxthread库需要2.0以上版本的Linux内核及相应版本的C库(libc 5.2.18、libc 5.4.12、libc 6)。

     2.“线程”控制

　　线程创建

　　进程被创建时，系统会为其创建一个主线程，而要在进程中创建新的线程，则可以调用pthread_create：

　　start_routine为新线程的入口函数，arg为传递给start_routine的参数。

　　每个线程都有自己的线程ID，以便在进程内区分。线程ID在pthread_create调用时回返给创建线程的调用者；一个线程也可以在创建后使用pthread_self()调用获取自己的线程ID：

　　线程退出

　　线程的退出方式有三：

　　（1）执行完成后隐式退出；

　　（2）由线程本身显示调用pthread_exit 函数退出；

　　（3）被其他线程用pthread_cance函数终止：

　　在某线程中调用此函数，可以终止由参数thread 指定的线程。

　　如果一个线程要等待另一个线程的终止，可以使用pthread_join函数，该函数的作用是调用pthread_join的线程将被挂起直到线程ID为参数thread的线程终止：

3.线程通信

　　线程互斥

　　互斥意味着“排它”，即两个线程不能同时进入被互斥保护的代码。Linux下可以通过pthread_mutex_t 定义互斥体机制完成多线程的互斥操作，该机制的作用是对某个需要互斥的部分，在进入时先得到互斥体，如果没有得到互斥体，表明互斥部分被其它线程拥有，此时欲获取互斥体的线程阻塞，直到拥有该互斥体的线程完成互斥部分的操作为止。

　　下面的代码实现了对共享全局变量x 用互斥体mutex 进行保护的目的：

　　线程同步

　　同步就是线程等待某个事件的发生。只有当等待的事件发生线程才继续执行，否则线程挂起并放弃处理器。当多个线程协作时，相互作用的任务必须在一定的条件下同步。

　　Linux下的C语言编程有多种线程同步机制，最典型的是条件变量(condition variable)。pthread_cond_init用来创建一个条件变量，其函数原型为：

　　pthread_cond_wait和pthread_cond_timedwait用来等待条件变量被设置，值得注意的是这两个等待调用需要一个已经上锁的互斥体mutex，这是为了防止在真正进入等待状态之前别的线程有可能设置该条件变量而产生竞争。pthread_cond_wait的函数原型为：

　　pthread_cond_broadcast用于设置条件变量，即使得事件发生，这样等待该事件的线程将不再阻塞：

　　pthread_cond_signal则用于解除某一个等待线程的阻塞状态：

　　pthread_cond_destroy 则用于释放一个条件变量的资源。

　　在头文件semaphore.h 中定义的信号量则完成了互斥体和条件变量的封装，按照多线程程序设计中访问控制机制，控制对资源的同步访问，提供程序设计人员更方便的调用接口。

　　这个函数初始化一个信号量sem 的值为val，参数pshared 是共享属性控制，表明是否在进程间共享。

　　调用该函数时，若sem为无状态，调用线程阻塞，等待信号量sem值增加(post )成为有信号状态；若sem为有状态，调用线程顺序执行，但信号量的值减一。

　　调用该函数，信号量sem的值增加，可以从无信号状态变为有信号状态。

创建线程或者进程的开销是很大的，为了防止频繁的创建线程，提高程序的运行效率，往往都会建立一个线程池用于多线程程序的调度

下面的程序就是完整的线程池实现，主要采用互斥量和条件变量实现同步

首先定义头文件threadpool.h

在该文件中定义了线程池的数据结构和所有的函数

#ifndef
THREADPOOL_H_
#define THREADPOOL_H_

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

/**
 * 线程体数据结构
 */
typedef struct
runner
{
 void
(*callback)(void* arg); // 回调函数指针
 void* arg;
// 回调函数的参数
 struct runner* next;
} thread_runner;

/**
 * 线程池数据结构
 */
typedef
struct
{
 pthread_mutex_t mutex; //互斥量
 pthread_cond_t cond; // 条件变量
 thread_runner* runner_head; // 线程池中所有等待任务的头指针
 thread_runner* runner_tail; // 线程池所有等待任务的尾指针
 int shutdown; // 线程池是否销毁
 pthread_t* threads; // 所有线程
 int max_thread_size; //线程池中允许的活动线程数目
} thread_pool;

/**
 * 线程体
 */
void run(void *arg);

/**
 * 初始化线程池
 *
 参数：
 *
  pool：指向线程池结构有效地址的动态指针
 *
  max_thread_size：最大的线程数
 */
void threadpool_init(thread_pool* pool, int
max_thread_size);

/**
 * 向线程池加入任务
 *
 参数：
 *
  pool：指向线程池结构有效地址的动态指针
 *
  callback：线程回调函数
 *
  arg：回调函数参数
 */
void threadpool_add_runner(thread_pool* pool, void
(*callback)(void *arg), void *arg);

/**
 * 销毁线程池
 *
 参数：
 *
  ppool：指向线程池结构有效地址的动态指针地址(二级指针)，销毁后释放内存，该指针为NULL
 */
void
threadpool_destroy(thread_pool** ppool);

#endif

然后是函数实现threadpool.h

该文件实现了threadpool.h的函数定义

#include
"threadpool.h"

#define
DEBUG 1

/**
 * 线程体
 */
void run(void *arg)
{
 thread_pool* pool = (thread_pool*) arg;
 while (1)
 {
  //
加锁
  pthread_mutex_lock(&(pool->mutex));
#ifdef DEBUG
  printf("run-> locked\n");
#endif
  //
如果等待队列为0并且线程池未销毁，则处于阻塞状态
  while
(pool->runner_head == NULL && !pool->shutdown)
  {
   pthread_cond_wait(&(pool->cond),
&(pool->mutex));
  }
  //如果线程池已经销毁
  if (pool->shutdown)
  {
   // 解锁
   pthread_mutex_unlock(&(pool->mutex));
#ifdef DEBUG
   printf("run-> unlocked and thread
exit\n");
#endif
   pthread_exit(NULL);
  }
  // 取出链表中的头元素
  thread_runner *runner =
pool->runner_head;
  pool->runner_head = runner->next;
  // 解锁
  pthread_mutex_unlock(&(pool->mutex));
#ifdef DEBUG
  printf("run-> unlocked\n");
#endif
  //
调用回调函数，执行任务
  (runner->callback)(runner->arg);
  free(runner);
  runner = NULL;
#ifdef DEBUG
  printf("run-> runned and free
runner\n");
#endif
 }
 pthread_exit(NULL);
}

/**
 * 初始化线程池
 *
 参数：
 *
  pool：指向线程池结构有效地址的动态指针
 *
  max_thread_size：最大的线程数
 */
void threadpool_init(thread_pool* pool, int
max_thread_size)
{
 // 初始化互斥量
 pthread_mutex_init(&(pool->mutex),
NULL);
 // 初始化条件变量
 pthread_cond_init(&(pool->cond),
NULL);
 pool->runner_head = NULL;
 pool->runner_tail = NULL;
 pool->max_thread_size = max_thread_size;
 pool->shutdown = 0;
 // 创建所有分离态线程
 pool->threads = (pthread_t *)
malloc(max_thread_size * sizeof(pthread_t));
 int i = 0;
 for (i = 0; i < max_thread_size; i++)
 {
  pthread_attr_t attr;
  pthread_attr_init(&attr);
  pthread_attr_setdetachstate(&attr,
PTHREAD_CREATE_DETACHED);
  pthread_create(&(pool->threads[i]),
&attr, (void*) run, (void*) pool);
 }
#ifdef DEBUG
 printf("threadpool_init-> create %d detached
thread\n", max_thread_size);
#endif
}

/**
 * 向线程池加入任务
 *
 参数：
 *
  pool：指向线程池结构有效地址的动态指针
 *
  callback：线程回调函数
 *
  arg：回调函数参数
 */
void threadpool_add_runner(thread_pool* pool, void
(*callback)(void *arg), void *arg)
{
 // 构造一个新任务
 thread_runner *newrunner = (thread_runner *)
malloc(sizeof(thread_runner));
 newrunner->callback = callback;
 newrunner->arg = arg;
 newrunner->next = NULL;
 // 加锁
 pthread_mutex_lock(&(pool->mutex));
#ifdef DEBUG
 printf("threadpool_add_runner->
locked\n");
#endif
 // 将任务加入到等待队列中
 if (pool->runner_head != NULL)
 {
  pool->runner_tail->next =
newrunner;
  pool->runner_tail =
newrunner;
 }
 else
 {
  pool->runner_head = newrunner;
  pool->runner_tail = newrunner;
 }
 // 解锁
 pthread_mutex_unlock(&(pool->mutex));
#ifdef DEBUG
 printf("threadpool_add_runner->
unlocked\n");
#endif
 // 唤醒一个等待线程
 pthread_cond_signal(&(pool->cond));
#ifdef DEBUG
 printf("threadpool_add_runner-> add a runner
and wakeup a waiting thread\n");
#endif
}

/**
 * 销毁线程池
 *
 参数：
 *
  ppool：指向线程池结构有效地址的动态指针地址(二级指针)
 */
void
threadpool_destroy(thread_pool** ppool)
{
 thread_pool *pool = *ppool;
 // 防止2次销毁
 if
(!pool->shutdown)
 {
  pool->shutdown = 1;
  // 唤醒所有等待线程，线程池要销毁了
  pthread_cond_broadcast(&(pool->cond));
  // 等待所有线程中止
  sleep(1);
#ifdef DEBUG
  printf("threadpool_destroy-> wakeup all
waiting threads\n");
#endif
  // 回收空间
  free(pool->threads);
  // 销毁等待队列
  thread_runner *head = NULL;
  while (pool->runner_head != NULL)
  {
   head = pool->runner_head;
   pool->runner_head =
pool->runner_head->next;
   free(head);
  }

#ifdef
DEBUG
  printf("threadpool_destroy->
all runners freed\n");
#endif
  /*条件变量和互斥量也别忘了销毁*/
  pthread_mutex_destroy(&(pool->mutex));
  pthread_cond_destroy(&(pool->cond));

#ifdef
DEBUG
  printf("threadpool_destroy->
mutex and cond destoryed\n");
#endif
  free(pool);
  (*ppool) = NULL;

#ifdef
DEBUG
  printf("threadpool_destroy->
pool freed\n");
#endif
 }
}

以上就是完整的线城池实现

下面写个测试程序来看看

#include
"threadpool.h"

void
threadrun(void* arg)
{
 int *i = (int *) arg;
 printf("%d\n", *i);
}

int
main(void)
{
 thread_pool *pool =
malloc(sizeof(thread_pool));
 threadpool_init(pool, 2);
 int i;
 int
tmp[3];
 for (i = 0; i < 3; i++)
 {
  tmp[i] = i;
  threadpool_add_runner(pool, threadrun,
&tmp[i]);
 }
 sleep(1);
 threadpool_destroy(&pool);
 printf("main-> %p\n",pool);
 printf("main-> test over\n");
 return 0;
}

该函数创建了1个线程池，包含2个线程，然后往线程池中加入了3个任务

并在最后打印了线程池的指针地址(主要是为了看线程池销毁后的状态)

运行结果如下

输出的信息主要调试信息，

值得注意的是倒数第二行“main-> (nil)”

说明线程池销毁后，指向线程池的指针 =
NULL（这就是为什么在threadpool_destory函数为什么要用二级指针的原因）

[C++][Thread] 转：线程池原理及创建（C++实现）