pthread_mutex_t mutex

（2）初始化互斥锁

#include <pthread.h>
int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr);
返回值：成功返回 0；失败返回错误编号

要用默认的属性初始化互斥量，只需把 attr 设为 NULL。

（3）使用互斥量进行加锁

#include <pthread.h>
int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_trylock(pthread_mutex_t *mutex);
返回值：若成功返回 0,；失败返回错误编号

对互斥量进行加锁，需要调用 pthread_mutex_lock。如果互斥量已经上锁，调用线程将阻塞直到互斥量被解锁。

#include <pthread.h>
int pthread_mutex_unlock(pthread_mutex_t *mutex);
返回值：若成功返回 0,；失败返回错误编号

（5）如果不再使用，则销毁互斥量

#include <pthread.h>
int pthread_mutex_destroy(pthread_mutex_t *mutex);
返回值：成功返回 0；失败返回错误码

3、示例说明

//使用互斥量解决多线程抢占资源的问题
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>char* buf[5]; //字符指针数组  全局变量
int pos; //用于指定上面数组的下标//1.定义互斥量
pthread_mutex_t mutex;void* task(void* p)
{//3.使用互斥量进行加锁pthread_mutex_lock(&mutex);buf[pos] = p;sleep(1);pos++;//4.使用互斥量进行解锁pthread_mutex_unlock(&mutex);
}int main(void)
{//2.初始化互斥量pthread_mutex_init(&mutex,0);//1.启动一个线程 向数组中存储内容pthread_t tid,tid2;pthread_create(&tid,NULL,task,"zhangfei");pthread_create(&tid2,NULL,task,"guanyu");//2.主线程进程等待,并且打印最终的结果pthread_join(tid,NULL);pthread_join(tid2,NULL);//5.销毁互斥量pthread_mutex_destroy(&mutex);int i = 0;printf("字符指针数组中的内容是：");for(i = 0; i < pos; i++){printf("%s ",buf[i]);}printf("\n");return 0;
}编译：# gcc test.c -lpthread
输出结果：
字符指针数组中的内容是：guanyu zhangfei

4、示例解析

多线程抢占资源，zhangfei、guanyu 线程阻塞不能同时给数组赋值的，所以用到互斥锁。

1、什么是死锁呢？

//使用互斥量解决多线程抢占资源的问题
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>char* buf[5]; //字符指针数组  全局变量
int pos; //用于指定上面数组的下标//1.定义互斥量
pthread_mutex_t mutex;void* task(void* p)
{//3.使用互斥量进行加锁pthread_mutex_lock(&mutex);pthread_mutex_lock(&mutex);buf[pos] = p;sleep(1);pos++;//4.使用互斥量进行解锁pthread_mutex_unlock(&mutex);pthread_mutex_unlock(&mutex);
}int main(void)
{//2.初始化互斥量pthread_mutex_init(&mutex,0);//1.启动一个线程 向数组中存储内容pthread_t tid,tid2;pthread_create(&tid,NULL,task,"zhangfei");pthread_create(&tid2,NULL,task,"guanyu");//2.主线程进程等待,并且打印最终的结果pthread_join(tid,NULL);pthread_join(tid2,NULL);//5.销毁互斥量pthread_mutex_destroy(&mutex);int i = 0;printf("字符指针数组中的内容是：");for(i = 0; i < pos; i++){printf("%s ",buf[i]);}printf("\n");return 0;
}
两个嵌套的互斥锁会产生死锁

2、产生条件

（1）预防死锁

这是一种较简单和直观的事先预防的方法。方法是通过设置某些限制条件，去破坏产生死锁的四个必要条件中的一个或者几个，来预防发生死锁。预防死锁是一种较易实现的方法，已被广泛使用。但是由于所施加的限制条件往往太严格，可能会导致系统资源利用率和系统吞吐量降低。

（2）避免死锁

该方法同样是属于事先预防的策略，但它并不须事先采取各种限制措施去破坏产生死锁的的四个必要条件，而是在资源的动态分配过程中，用某种方法去防止系统进入不安全状态，从而避免发生死锁。

（3）检测和解除死锁

先检测：这种方法并不须事先采取任何限制性措施，也不必检查系统是否已经进入不安全区，此方法允许系统在运行过程中发生死锁。但可通过系统所设置的检测机构，及时地检测出死锁的发生，并精确地确定与死锁有关的进程和资源。检测方法包括定时检测、效率低时检测、进程等待时检测等。然后解除死锁：采取适当措施，从系统中将已发生的死锁清除掉。

#include <pthread.h>
#include <time.h>int pthread_mutex_timedlock(pthread_mutex_t *restrict mutex,
const struct timespec *restrict abs_timeout);
返回值：成功返回 0；失败返回错误编号

1、函数功能

#include <stdio.h>
#include <pthread.h>
#include <time.h>
#include "apue.h"int main (void)
{int err;struct timespec tout;struct tm *tmp;char buf[64];pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;pthread_mutex_lock (&lock);printf ("mutex is locked\n");clock_gettime (CLOCK_REALTIME, &tout);tmp = localtime (&tout.tv_sec); strftime (buf, sizeof (buf), "%r", tmp);printf ("current time is %s\n", buf);tout.tv_sec += 10;err = pthread_mutex_timedlock (&lock, &tout);clock_gettime (CLOCK_REALTIME, &tout);tmp = localtime (&tout.tv_sec);strftime (buf, sizeof (buf), "%r", tmp);printf ("the time is now %s\n", buf);if (err == 0)printf ("mutex locked again\n");else printf ("can`t lock mutex again:%s\n", strerror (err));return 0;
}
编译：# gcc test.c  -lpthread -lrt 输出结果：
mutex is locked
current time is 03:11:30 PM
the time is now 03:11:40 PM
can`t lock mutex again:Connection timed out

3、示例解析

#include <pthread.h>
int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock, const pthread_rwlockattr_t *restrict attr);
int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);
两个函数返回值：若成功，返回 0；否则，返回错误编号

读写锁通过调用 pthread_rwlock_init 进行动态初始化。如果希望读写锁有默认的属性，可以传一个 NULL 指针给 attr。可以调用常量 PTHREAD_RWLOCK_INITIALIZER 进行静态初始化。

#include <pthread.h>
int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);
成功则返回0, 出错则返回错误编号.

要在读模式下锁定读写锁，需要调用 pthread_rwlock_rdlock

#include<stdio.h>
#include<unistd.h>
#include<pthread.h>  pthread_rwlock_t rwlock; //读写锁
int num = 1;  //读操作，其他线程允许读操作，却不允许写操作
void *fun1(void *arg)
{  while(1)  {  pthread_rwlock_rdlock(&rwlock);  printf("read num first===%d\n",num);  pthread_rwlock_unlock(&rwlock);  sleep(1);  }
}  //读操作，其他线程允许读操作，却不允许写操作
void *fun2(void *arg)
{  while(1)  {  pthread_rwlock_rdlock(&rwlock);  printf("read num second===%d\n",num);  pthread_rwlock_unlock(&rwlock);  sleep(2);  }
}  //写操作，其它线程都不允许读或写操作
void *fun3(void *arg)
{  while(1)  {  pthread_rwlock_wrlock(&rwlock);  num++;  printf("write thread first\n");  pthread_rwlock_unlock(&rwlock);  sleep(2);  }
}  //写操作，其它线程都不允许读或写操作
void *fun4(void *arg)
{  while(1)  {  pthread_rwlock_wrlock(&rwlock);  num++;  printf("write thread second\n");  pthread_rwlock_unlock(&rwlock);  sleep(1);  }
}  int main()
{  pthread_t ptd1, ptd2, ptd3, ptd4;  pthread_rwlock_init(&rwlock, NULL);//初始化一个读写锁  //创建线程  pthread_create(&ptd1, NULL, fun1, NULL);  pthread_create(&ptd2, NULL, fun2, NULL);  pthread_create(&ptd3, NULL, fun3, NULL);  pthread_create(&ptd4, NULL, fun4, NULL);  //等待线程结束，回收其资源  pthread_join(ptd1,NULL);  pthread_join(ptd2,NULL);  pthread_join(ptd3,NULL);  pthread_join(ptd4,NULL);  pthread_rwlock_destroy(&rwlock);//销毁读写锁  return 0;
}
编译：# gcc test.c -lpthread输出结果：
write thread second
write thread first
read num second===3
read num first===3
write thread second
read num first===4
write thread first
read num second===5
write thread second
read num first===6
.....

4、示例解析

在此示例程序中，共创建了 4 个线程，其中两个线程用来写入数据，两个线程用来读取数据。

六、条件变量

1、条件变量概念

#include <pthread.h>int pthread_cond_destroy(pthread_cond_t *cond);
int pthread_cond_init(pthread_cond_t *restrict cond,
const pthread_condattr_t *restrict attr);
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
两个函数的返回值：若成功，返回 0；否则，返回错误编号

（1）参数解析

3、条件变量等待

#include <pthread.h>int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);
int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime);
两个函数的返回值：若陈宫，返回 0；否则，返回错误编号

（1）参数解析

pthread_mutex_lock();
while (condition_is_false) pthread_cond_wait();
pthread_mutex_unlock();

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

#include <pthread.h>int pthread_cond_broadcast(pthread_cond_t *cond);
int pthread_cond_signal(pthread_cond_t *cond);
两个函数的返回值：若成功，返回 0；否则，返回错误编号

（1）函数解析

//示例一
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>  pthread_cond_t taxicond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t taximutex = PTHREAD_MUTEX_INITIALIZER;  void *traveler_arrive(void *name)
{  char *p = (char *)name;  printf ("Travelr: %s need a taxi now!\n", p);  pthread_mutex_lock(&taximutex);  pthread_cond_wait(&taxicond, &taximutex);  pthread_mutex_unlock(&taximutex);  printf ("traveler: %s now got a taxi!\n", p);  pthread_exit(NULL);
}  void *taxi_arrive(void *name)
{  char *p = (char *)name;  printf ("Taxi: %s arrives.\n", p);  pthread_cond_signal(&taxicond);  pthread_exit(NULL);
}  int main (int argc, char **argv)
{  char *name;  pthread_t thread;  pthread_attr_t threadattr;  pthread_attr_init(&threadattr);  name = "Jack";  pthread_create(&thread, &threadattr, taxi_arrive, name);  sleep(1);  name = "Susan";  pthread_create(&thread, &threadattr, traveler_arrive, name);  sleep(1);  name = "Mike";  pthread_create(&thread, &threadattr, taxi_arrive, name);  sleep(1);  return 0;
}
编译：# gcc test.c  -lpthread输出结果：
Taxi: Jack arrives.
Travelr: Susan need a taxi now!
Taxi: Mike arrives.
traveler: Susan now got a taxi!

//示例二
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>  int travelercount = 0;
pthread_cond_t taxicond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t taximutex = PTHREAD_MUTEX_INITIALIZER;  void *traveler_arrive(void *name)
{  char *p = (char *)name;  pthread_mutex_lock(&taximutex);  printf ("traveler: %s need a taxi now!\n", p);  travelercount++;  pthread_cond_wait(&taxicond, &taximutex);  pthread_mutex_unlock(&taximutex);  printf ("traveler: %s now got a taxi!\n", p);  pthread_exit(NULL);
}  void *taxi_arrive(void *name)
{  char *p = (char *)name;  printf ("Taxi: %s arrives.\n", p);  for(;;){  if(travelercount){  pthread_cond_signal(&taxicond);  travelercount--;  break;  }  }  pthread_exit(NULL);
}  int main (int argc, char **argv)
{  char *name;  pthread_t thread;  pthread_attr_t threadattr;  pthread_attr_init(&threadattr);  name = "Jack";  pthread_create(&thread, &threadattr, taxi_arrive, name);  sleep(1);  name = "Susan";  pthread_create(&thread, &threadattr, traveler_arrive, name);  sleep(3);  name = "Mike";  pthread_create(&thread, &threadattr, taxi_arrive, name);  sleep(4);  return 0;
}
编译：# gcc test.c  -lpthread输出结果：
Taxi: Jack arrives.
traveler: Susan need a taxi now!
traveler: Susan now got a taxi!
Taxi: Mike arrives.

七、自旋锁