Linux互斥锁和代码实现、死锁

互斥锁Mutex

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

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

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

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

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

pthread_mutex_init

restrict

c99中新增加了一个类型定义，就是restrict。
概括的说，关键字restrict只用于限定指针；该关键字用于告知编译器，所有修改该指针所指向内容的操作全部都是基于(base on)该指针的，即不存在其它进行修改操作的途径；这样的后果是帮助编译器进行更好的代码优化，生成更有效率的汇编代码。举个简单的例子：

int foo (int* x, int* y) {
    *x = 0;
    *y = 1;
    return *x;
}

很显然函数foo()的返回值是0，除非参数x和y的值相同。可以想象，99％的情况下该函数都会返回0而不是1。然而编译起必须保证生成100%正确的代码，因此，编译器不能将原有代码替换成下面的更优版本

int f (int* x, int* y) {
    *x = 0;
    *y = 1;
    return 0;
}

现在我们有了restrict这个关键字，就可以利用它来帮助编译器安全的进行代码优化了：

int f (int *restrict x, int *restrict y) {
    *x = 0;
    *y = 1;
    return *x;
}

此时，由于指针 x 是修改 *x的唯一途径，编译起可以确认 “*y=1; ”这行代码不会修改 *x的内容，因此可以安全的优化为：

int f (int *restrict x, int *restrict y) {
    *x = 0;
    *y = 1;
    return 0;
}

最后注意一点，restrict是C99中定义的关键字，C++目前并未引入；在GCC可通过使用参数” -std=c99”
来开启对C99的支持。下面是我从C语言核心技术一书上摘的：

void *memcpy( void * restrict dest , const void * restrict src, size_t n) 

这是一个很有用的内存复制函数，由于两个参数都加了restrict限定，所以两块区域不能重叠，即 dest指针所指的区域，不能让别的指针来修改，即src的指针不能修改. 相对应的别一个函数 memmove(void *dest, const void *src, size_t)则可以重叠。

pthread_mutex_destroy函数

pthread_mutex_lock函数

pthread_mutex_unlock函数

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_fun_1(void *arg)
{
    char *str = "hello";
    printer(str); //打印
}
​
// 线程二
void *thread_fun_2(void *arg)
{
    char *str = "world";
    printer(str); //打印
}
​
int main(void)
{
    pthread_t tid1, tid2;
​
    pthread_mutex_init(&mutex, NULL); //初始化互斥锁
​
    // 创建 2 个线程
    pthread_create(&tid1, NULL, thread_fun_1, NULL);
    pthread_create(&tid2, NULL, thread_fun_2, NULL);
​
    // 等待线程结束，回收其资源
    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
​
    pthread_mutex_destroy(&mutex); //销毁互斥锁
​
    return 0;
}

死锁场景

场景演示：

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

pthread_mutex_t mutex1;
pthread_mutex_t mutex2;
//线程1处理函数
void* func1(void* arg)
{
	//线程1先申请资源1，再申请资源2
	pthread_mutex_lock(&mutex1);
	printf("线程1加锁资源1 ok...\n");
	pthread_mutex_lock(&mutex2);
	printf("线程1加锁资源2 ok...\n");
	
	printf("线程1执行临界区代码...\n");
	
	//解互斥锁
	pthread_mutex_unlock(&mutex1);
	pthread_mutex_unlock(&mutex2);
	return NULL;
}
//线程2处理函数
void* func2(void* arg)
{
	//线程1先申请资源2，再申请资源1
	pthread_mutex_lock(&mutex2);
	printf("线程2加锁资源2 ok...\n");
	pthread_mutex_lock(&mutex1);
	printf("线程2加锁资源1 ok...\n");
	
	printf("线程2执行临界区代码...\n");
	
	//解互斥锁
	pthread_mutex_unlock(&mutex2);
	pthread_mutex_unlock(&mutex1);
	return NULL;
}

//演示死锁
int main()
{
	int ret=-1;
	pthread_t tid1,tid_2;
	//互斥量初始化
	pthread_mutex_init(&mutex1,NULL);
	printf("");
	pthread_mutex_init(&mutex2,NULL);

	//创建两个线程
	pthread_create(&tid1,NULL,fun1,NULL);
	pthread_create(&tid2,NULL,fun2,NULL);

	//回收线程资源
	ret = pthread_join(tid1,NULL);
	if(0 != ret)
	{
		printf("pthread_join failed...\n");
		return 1;
	}
	ret = pthread_join(tid2,NULL);
	if(0 != ret)
	{
		printf("pthread_join failed...\n");
		return 1;
	}
	//销毁
	pthread_mutex_destroy(&mutex1);
	pthread_mutex_destroy(&mutex2);
}

直接死锁