互斥锁

为什么需要互斥锁？

在多任务操作系统中，同时运行的多个任务可能都需要使用同一种资源。这个过程有点类似于，公司部门里，我在使用着打印机打印东西的同时（还没有打印完），别人刚好也在此刻使用打印机打印东西，如果不做任何处理的话，打印出来的东西肯定是错乱的。

下面我们用程序模拟一下这个过程，线程一需要打印“ hello ”，线程二需要打印“ world ”，不加任何处理的话，打印出来的内容会错乱：

实际上，打印机是有做处理的，我在打印着的时候别人是不允许打印的，只有等我打印结束后别人才允许打印。这个过程有点类似于，把打印机放在一个房间里，给这个房间安把锁，这个锁默认是打开的。当 A 需要打印时，他先过来检查这把锁有没有锁着，没有的话就进去，同时上锁在房间里打印。而在这时，刚好 B 也需要打印，B 同样先检查锁，发现锁是锁住的，他就在门外等着。而当 A 打印结束后，他会开锁出来，这时候 B 才进去上锁打印。

而在线程里也有这么一把锁——互斥锁（mutex），互斥锁是一种简单的加锁的方法来控制对共享资源的访问，互斥锁只有两种状态,即上锁( lock )和解锁( unlock )。

互斥锁的操作流程如下：

1）在访问共享资源后临界区域前，对互斥锁进行加锁。

2）在访问完成后释放互斥锁导上的锁。

3）对互斥锁进行加锁后，任何其他试图再次对互斥锁加锁的线程将会被阻塞，直到锁被释放。

互斥锁的数据类型是： pthread_mutex_t。

互斥锁基本操作

以下函数需要的头文件：

#include <pthread.h>

1）初始化互斥锁

int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr);

功能：

初始化一个互斥锁。

参数：

mutex：互斥锁地址。类型是 pthread_mutex_t 。
attr：设置互斥量的属性，通常可采用默认属性，即可将 attr 设为 NULL。

可以使用宏 PTHREAD_MUTEX_INITIALIZER 静态初始化互斥锁，比如：

pthread_mutex_t  mutex = PTHREAD_MUTEX_INITIALIZER;

这种方法等价于使用 NULL 指定的 attr 参数调用  pthread_mutex_init () 来完成动态初始化，不同之处在于  PTHREAD_MUTEX_INITIALIZER  宏不进行错误检查。

返回值：

成功：0，成功申请的锁默认是打开的。

失败：非 0 错误码

2）上锁

int pthread_mutex_lock(pthread_mutex_t *mutex);

功能：

对互斥锁上锁，若互斥锁已经上锁，则调用者一直阻塞，直到互斥锁解锁后再上锁。

参数：

mutex：互斥锁地址。

返回值：

成功：0

失败：非 0 错误码

int pthread_mutex_trylock(pthread_mutex_t *mutex);

调用该函数时，若互斥锁未加锁，则上锁，返回 0；若互斥锁已加锁，则函数直接返回失败，即 EBUSY。

3）解锁

int pthread_mutex_unlock(pthread_mutex_t * mutex);

功能：

对指定的互斥锁解锁。

参数：

mutex：互斥锁地址。

返回值：

成功：0

失败：非 0 错误码

4）销毁互斥锁

int pthread_mutex_destroy(pthread_mutex_t *mutex);

功能：

销毁指定的一个互斥锁。互斥锁在使用完毕后，必须要对互斥锁进行销毁，以释放资源。

参数：

mutex：互斥锁地址。

返回值：

成功：0

失败：非 0 错误码

互斥锁应用实例

我们通过互斥锁完善上面的例子，示例代码如下：

#include <stdio.h>
#include <stdlib.h>
#include <stdio.h>  
#include <pthread.h>  
#include "unistd.h" 
#include <windows.h>
#include <dos.h>
#include <iostream> // std::cout
#include <thread>   // std::thread
pthread_mutex_t mutex; //互斥锁 
void printer(char *str)
{
	pthread_mutex_lock(&mutex); //上锁  
	while (*str != '\0')
	{
		putchar(*str);
		fflush(stdout);
		str++;
		Sleep(1);
	}
	printf("\n");
	pthread_mutex_unlock(&mutex); //解锁  
}
void thread_task1() {
	char *str = "hello";
	printer(str) ; //打印  
}
void thread_task2() {
	char *str = "world";
	printer(str); //打印  
}

/*
* ===  FUNCTION  =========================================================
*         Name:  main
*  Description:  program entry routine.
* ========================================================================
*/
int main(int argc, const char *argv[])
{
	pthread_mutex_init(&mutex, NULL); //初始化互斥锁  
	std::thread t2(thread_task2);
	std::thread t1(thread_task1);
	
	t1.join();
	t2.join();
	pthread_mutex_destroy(&mutex);
	return EXIT_SUCCESS;
}  /* ----------  end of function main  ---------- */

若没有加互斥锁，则两个进程使用相同的资源，则会产生错乱。

打印出wheorllldo

死锁

典型的场景简单说就是有不止一把互斥锁，两个执行线程当前各自持有一把锁，却又在等待对方已经持有的锁释放，这样永远都跳不出等待。如果避免不了要同时持有多个锁的话，那就按照固定的顺序去加锁，实际代码中可以比较锁对象的内存地址，先对内存地址小的锁加锁（但这无疑会增加维护的成本）。

死锁问题:
出现条件，至少两个线程，两把锁。 
举例：
两个线程为甲和乙， 两把锁为A 和 B.
甲线程申请了锁A, 再申请锁B, 才能完成工作。
乙线程申请了锁B, 再申请锁A, 才能完成工作。
当甲线程申请到锁A, 等待锁B, 乙线程申请到锁B, 等待锁A, 就造成死锁。
死锁后，甲，乙两线程均不能运行。

解决办法: 打破这种互套关系即可。
如果两把锁可以不互相嵌套， 则死锁解除。
例如: 乙线程申请了锁B, 完成部分工作，然后释放锁B, 再申请锁A, 完成部分工作，再释放锁A.  则死锁解除。
数据锁要仅保护数据，不保护未知调用。