POSIX多线程互斥量及其应用

pthread_mutex_t _mutex = PTHREAD_MUTEX_INITIALIZER; ①

int pthread_mutex_init( pthread_mutex_t *mutex, pthread_mutex attr_t *attr );②

int pthread_mutex_destroy (pthread_mutex_t *mutex);

程序中的互斥量是用pthread_mutex_t类型的变量来表示的，不能拷贝互斥量变量，因为是用拷贝的互斥量是不确定的。但是可以拷贝指向互斥量的指针，这样就可以使多个函数或线程共享互斥量来实现同步。

创建和销毁互斥量：

互斥量一般声明为两种类型，在函数体外、文件范围内使用声明为静态类型；如果有其他文件使用则声明为外部类型。当使用malloc动态分配一个包含互斥量的数据结构时，通常不采用静态方式(①)初始化一个互斥量，此时应使用pthread_mutex_init(②)来动态初始化静态类型的互斥量。如果要动态初始化静态类型的互斥量，则必须保证每个互斥量在使用前被初始化且只能被初始化一次。当初始化一个非缺省属性的互斥量时，则必须使用动态初始化。

当不再需要一个通过pthread_mutex_init动态初始化的互斥量时，应调用int pthread_mutex_destroy来释放它。而使用PTHREAD_MUTEX_INITIALIZER宏初始化的互斥量则不需要被释放。

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_lock或pthread_mutex_trylock锁住互斥量，处理共享数据，然后调用pthread_mutex_unlock解锁互斥量。

当调用线程已经锁住互斥量之后，就不能再加锁该互斥量。试图这样做的结果可能是返回错误(EDEADLK)或者可能陷入“自死锁”，使线程永远等待下去。不能解锁一个已经解锁的互斥量，也不能解锁由其他线程锁住的互斥量。被锁住的互斥量是属于加锁线程的。

接下来贴一段使用互斥量版本的闹钟例子(运行环境为ubuntu + Qt)：

#include <QCoreApplication>

#include <pthread.h>

#include <time.h>

#include "errors.h"

#include <QDebug>

typedef struct alarm_tag {

struct alarm_tag *link;

int seconds;

time_t time; /* seconds from EPOCH */

char message[64];

} alarm_t;

pthread_mutex_t alarm_mutex = PTHREAD_MUTEX_INITIALIZER;

alarm_t *alarm_list = NULL;

void *alarm_thread (void *arg)

{

alarm_t *alarm;

int sleep_time;

time_t now;

int status;

while (1) {

status = pthread_mutex_lock (&alarm_mutex);

if (status != 0)

err_abort (status, "Lock mutex");

alarm = alarm_list;

if (alarm == NULL)

sleep_time = 1;

else {

alarm_list = alarm->link;

now = time (NULL);

if (alarm->time <= now)

sleep_time = 0;

else

sleep_time = alarm->time - now;

#ifdef DEBUG

printf ("[waiting: %d(%d)\"%s\"]\n", alarm->time,

sleep_time, alarm->message);

#endif

}

status = pthread_mutex_unlock (&alarm_mutex);

if (status != 0)

err_abort (status, "Unlock mutex");

if (sleep_time > 0)

sleep (sleep_time);

else

sched_yield ();

if (alarm != NULL) {

printf ("(%d) %s\n", alarm->seconds, alarm->message);

free (alarm);

}

}

}

int main(int argc, char *argv[])

{

// QCoreApplication a(argc, argv);

int status;

char line[128];

alarm_t *alarm, **last, *next;

pthread_t thread;

status = pthread_create (

&thread, NULL, alarm_thread, NULL);

if (status != 0)

err_abort (status, "Create alarm thread");

while (1) {

printf ("alarm> ");

if (fgets (line, sizeof (line), stdin) == NULL) exit (0);

if (strlen (line) <= 1) continue;

alarm = (alarm_t*)malloc (sizeof (alarm_t));

if (alarm == NULL)

errno_abort ("Allocate alarm");

if (sscanf (line, "%d %64[^\n]",

&alarm->seconds, alarm->message) < 2) {

fprintf (stderr, "Bad command\n");

free (alarm);

} else {

status = pthread_mutex_lock (&alarm_mutex);

if (status != 0)

err_abort (status, "Lock mutex");

alarm->time = time (NULL) + alarm->seconds;

last = &alarm_list;

next = *last;

while (next != NULL) {

if (next->time >= alarm->time) {

alarm->link = next;

*last = alarm;

break;

}

last = &next->link;

next = next->link;

}

if (next == NULL) {

*last = alarm;

alarm->link = NULL;

}

#ifdef DEBUG

printf ("[list: ");

for (next = alarm_list; next != NULL; next = next->link)

printf ("%d(%d)[\"%s\"] ", next->time,

next->time - time (NULL), next->message);

printf ("]\n");

#endif

status = pthread_mutex_unlock (&alarm_mutex);

if (status != 0)

err_abort (status, "Unlock mutex");

}

}

// return a.exec();

}

上面程序是对多线程版本闹钟程序的改进。

简单理下程序结构：

alarm_t结构体包含了一个标准UNIX time_t类型的绝对时间，表示从UNIX纪元(1970年1月1日 00:00)开始到闹铃时的秒数。线程函数依次处理alarm_list 中每个闹钟的请求，线程永不停止，当main函数返回时，线程“政蒸发”。如果列表中没有闹钟请求，则线程阻塞自己1秒，解锁互斥量，以便主线程可以添加新的闹钟请求。

在线程睡眠或阻塞之前，总要解锁互斥量。如果互斥量仍被锁住，则主线程即就无法向列表中添加请求，这将使程序变成同步工作方式。调用sched_yield则变得不同，现在只需简单理解为将处理器交给另一个等待运行的线程。

主函数程序与之前差别不大，主要是讲闹钟请求排序后加入闹钟结构体中。

该改进版本有几个缺点。虽然与多进程版本和多线程版本相比，该版本占用的资源很少，但是响应性不够好。改进的方法是使用条件变量来通知共享数据状态的变化，之后我们会有说明。