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则变得不同，现在只需简单理解为将处理器交给另一个等待运行的线程。
主函数程序与之前差别不大，主要是讲闹钟请求排序后加入闹钟结构体中。
该改进版本有几个缺点。虽然与多进程版本和多线程版本相比，该版本占用的资源很少，但是响应性不够好。改进的方法是使用条件变量来通知共享数据状态的变化，之后我们会有说明。