linux系统编程7-锁、信号量、线程同步

一、同步概念

主旨在协同步调,按预定的先后次序运行。

1、线程同步

线程同步,指一个线程发出某一功能调用时,在没有得到结果之前,该调用不返回。同时其它线程为保证数据一致性,不能调用该功能。

“同步”的目的,是为了避免数据混乱,解决与时间有关的错误。实际上,不仅线程间需要同步,进程间、信号间等等都需要同步机制。

因此,所有“多个控制流,共同操作一个共享资源”的情况,都需要同步。

2、数据混乱原因

  1. 资源共享(独享资源则不会)
  2. 调度随机(意味着数据访问会出现竞争)
  3. 线程间缺乏必要的同步机制。

以上3点中,前两点不能改变,欲提高效率,传递数据,资源必须共享。只要共享资源,就一定会出现竞争。只要存在竞争关系,数据就很容易出现混乱。
所以只能从第三点着手解决。使多个线程在访问共享资源的时候,出现互斥。

二、互斥量mutex

Linux中提供一把互斥锁mutex(也称之为互斥量)。
每个线程在对资源操作前都尝试先加锁,成功加锁才能操作,操作结束解锁。资源还是共享的,线程间也还是竞争的,
但通过“锁”就将资源的访问变成互斥操作,而后与时间有关的错误也不会再产生了。

建议锁!对公共数据进行保护。所有线程应该在访问公共数据前先拿锁再访问。但,锁本身不具备强制性。

1、使用mutex的基本步骤


	pthread_mutex_t 类型。 

	1. pthread_mutex_t lock;  创建锁

	2  pthread_mutex_init; 初始化		1

	3. pthread_mutex_lock;加锁		1--	--> 0

	4. 访问共享数据(stdout)		

	5. pthrad_mutext_unlock();解锁		0++	--> 1

	6. pthead_mutex_destroy;销毁锁

注意事项

		尽量保证锁的粒度, 越小越好。(访问共享数据前,加锁。访问结束【立即】解锁。)

		互斥锁,本质是结构体。 我们可以看成整数。 初值为 1。(pthread_mutex_init() 函数调用成功。)

		加锁: --操作, 阻塞线程。

		解锁: ++操作, 换醒阻塞在锁上的线 你  程。

		try锁:尝试加锁,成功--。失败,返回。同时设置错误号 EBUSY

	初始化互斥量:

		pthread_mutex_t mutex;

		1. pthread_mutex_init(&mutex, NULL);   			动态初始化。

		2. pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;	静态初始化。

2、主要应用函数

pthread_mutex_init函数
pthread_mutex_destroy函数
pthread_mutex_lock函数
pthread_mutex_trylock函数
pthread_mutex_unlock函数
以上5个函数的返回值都是:成功返回0,失败返回错误号。

pthread_mutex_t类型,其本质是一个结构体。为简化理解,应用时可忽略其实现细节,简单当成整数看待。pthread_mutex_t mutex;变量 mutex只有两种取值1、O。

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

3、加锁与解锁

使用锁时

4、加锁步骤测试

三、死锁


	是使用锁不恰当导致的现象:

		1. 对一个锁反复lock。

		2. 两个线程,各自持有一把锁,请求另一把。

四、读写锁

  1. 锁只有一把。以读方式给数据加锁——读锁。以写方式给数据加锁——写锁。
  2. 读共享,写独占。
  3. 写锁优先级高。

写正在占着资源时,这时候有读来了,也不会让给读
只有读和写在同一地位时,读优先的地位才会显现出来。

1、读写锁特性:

  1. 读写锁是“写模式加锁”时,解锁前,所有对该锁加锁的线程都会被阻塞。
  2. 读写锁是“读模式加锁”时,如果线程以读模式对其加锁会成功;如果线程以写模式加锁会阻塞。
  3. 读写锁是“读模式加锁”时,既有试图以写模式加锁的线程,也有试图以读模式加锁的线程。那么读写锁会阻塞随后的读模式锁请求。优先满足写模式锁。读锁、写锁并行阻塞,写锁优先级高时

读写锁也叫共享-独占锁。当读写锁以读模式锁住时,它是以共享模式锁住的;当它以写模式锁独占模式锁住的。写独占、读共享

读写锁非常适合于对数据结构读的次数远大于写的情况。

在这里插入图片描述
在这里插入图片描述

五、条件变量

条件变量本身不是锁!但它也可以造成线程阻塞。通常与互斥锁配合使用。给多线程提供一个会合的场所。

1、主要应用函数


pthread_cond_init函数
pthread_cond_destroy函数
pthread_cond_wait函数
pthread_cond_timedwait函数
pthread_cond_signal函数
pthread_cond_broadcast函数
以上6个函数的返回值都是:成功返回o,失败直接返回错误号。
pthread_cond_t类型用于定义条件变量
pthread_cond_t cond;

1) pthread_cond_init函数 初始化一个条件变量
int pthread_cond_init(pthread_cond_t *restrict cond, const pthread_condattr_t *restrict attr);2: attr表条件变量属性,通常为默认值,传 NULL即可

也可以使用静态初始化的方法,初始化条件变量:
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
2) pthread_cond_destroy函数 销毁一个条件变量
int pthread_cond_destroy(pthread_cond_t *cond);
3)pthread_cond_wait函数 阻塞等待一个条件变量

要有个互斥锁当参数,
互斥锁要求是实现已经锁上,这个函数将会释放这个锁,然后等待唤醒
比如生产者和消费者模型,消费者先对容器加锁,发现没有食物了,然后就会阻塞,程序就会停到当前位置,释放所占有的锁,然后让生产者拿着这个锁去放食物,让生产者发出信号把自己唤醒。

在这里插入图片描述

	int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex);

	函数作用:
	1.阻塞等待条件变量cond(参1)满足
	2.释放已掌握的互斥锁(解锁互斥量)相当于pthread_mutex_unlock(&mutex);
		1.2.两步为一个原子操作。
	3. 当被唤醒,pthread_cond_wait 函数返回时,解除阻塞并重新申请获取互斥锁pthread_mutex_lock(&mutex);
4) pthread_cond_timedwait函数 限时等待一个条件变量
int pthread_cond_timedwait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex, const struct timespec*restrict abstime);3:参看man sem_timedwait函数,查看struct timespec结构体。
		struct timespec {
			time_t tv_sec;/*seconds*/long tv_nsec;/* nanosecondes*/纳秒
	形参abstime:绝对时间。
		如: time(NULL)返回的就是绝对时间。而alarm(1)是相对时间,相对当前时间定时1秒钟。
		struct timespec t= {1,0};
		pthread_cond_timedwait (&cond,&mutex, &t);只能定时到19701100:00:01(早已经过去)正确用法:
		time_t cur = time(NULL);获取当前时间。
		struct timespec t;定义timespec 结构体变量tt.tv_sec = cur+1;定时1pthread_cond_timedwait (&cond,&mutex,&t);
在讲解setitimer函数时我们还提到另外一种时间类型:
		struct timeval {
			time_t
			tv_sec;/* seconds */秒
			suseconds_t tv_usec;/* microseconds*/微秒
	};

5)pthread_cond_signal函数 唤醒至少一个阻塞在条件变量上的线程
int pthread_cond_signal(pthread_cond_t *cond);
6) pthread_cond_broadcast函数 唤醒全部阻塞在条件变量上的线程
int pthread_cond_broadcast(pthread_cond_t *cond);

在这里插入图片描述

2、生产者消费者条件变量

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

/*借助条件变量模拟 生产者-消费者 问题*/
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <stdio.h>

/*链表作为公享数据,需被互斥量保护*/
struct msg {
    struct msg *next;
    int num;
};

struct msg *head;

/* 静态初始化 一个条件变量 和 一个互斥量*/
pthread_cond_t has_product = PTHREAD_COND_INITIALIZER;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;

void *consumer(void *p)
{
    struct msg *mp;

    for (;;) {
        pthread_mutex_lock(&lock);
        while (head == NULL) {           //头指针为空,说明没有节点    可以为if吗
            pthread_cond_wait(&has_product, &lock);
        }
        mp = head;      
        head = mp->next;                 //模拟消费掉一个产品
        pthread_mutex_unlock(&lock);

        printf("-Consume %lu---%d\n", pthread_self(), mp->num);
        free(mp);
        sleep(rand() % 5);
    }
}

void *producer(void *p)
{
    struct msg *mp;

    for (;;) {
        mp = malloc(sizeof(struct msg));
        mp->num = rand() % 1000 + 1;        //模拟生产一个产品
        printf("-Produce ---------------------%d\n", mp->num);

        pthread_mutex_lock(&lock);
        mp->next = head;
        head = mp;
        pthread_mutex_unlock(&lock);

        pthread_cond_signal(&has_product);  //将等待在该条件变量上的一个线程唤醒
        sleep(rand() % 5);
    }
}

int main(int argc, char *argv[])
{
    pthread_t pid, cid;
    srand(time(NULL));

    pthread_create(&pid, NULL, producer, NULL);
    pthread_create(&cid, NULL, consumer, NULL);

    pthread_join(pid, NULL);
    pthread_join(cid, NULL);

    return 0;
}

多个消费者那在main函数里面多建几个消费者,然后让其执行自己的程序。
在这里插入图片描述

3、条件变量的优点

相较于mutex而言,条件变量可以减少竞争。

如直接使用mutex,除了生产者、消费者之间要竞争互斥量以外,消费者之间也需要竞争互斥量,但如果汇聚(链表)中没有数据,消费者之间竞争互斥锁是无意义的。有了条件变量机制以后,只有生产者完成生产,才会引起消费者之间的竞争。提高了程序效率。

六、信号量

进化版的互斥锁(1–>N)
由于互斥锁的粒度比较大,如果我们希望在多个线程间对某一对象的部分数据进行共享,使用互斥锁是没有办法实现的,只能将整个数据对象锁住。这样虽然达到了多线程操作共享数据时保证数据正确性的目的,却无形中导致线程的并发性下降。线程从并行执行,变成了串行执行。与直接使用单进程无异。
信号量,是相对折中的一种处理方式,既能保证同步,数据不混乱,又能提高线程并发。

1、主要应用函数

sem_init函数
sem_destroy函数
sem_wait函数
sem_trywait 函数
sem_timedwait函数
sem_post函数

以上6个函数的返回值都是:成功返回o,失败返回-1,同时设置errno。(注意,它们没有 pthread前缀)

sem_t类型,本质仍是结构体。但应用期间可简单看作为整数,忽略实现细节(类似于使用文件描述符)。
sem_t sem;规定信号量sem不能<0。头文件<semaphore.h>

在这里插入图片描述

1)sem_init函数 初始化一个信号量
int sem_init(sem_t *sem, int pshared, unsigned int value);1: sem信号量
	参2: pshared取o用于线程间;取非0(一般为1)用于进程间
	参3: value指定信号量初值
2)sem_destroy函数 销毁一个信号量
int sem_destroy(sem_t *sem);
3) sem_wait函数 给信号量加锁
int sem_wait(sem_t *sem);
4)sem_post函数 给信号量解锁
int sem_post(sem_t *sem);
5) sem_trywait函数 尝试对信号量加锁

(与sem_wait的区别类比 lock 和 trylock)

int sem_trywait(sem_t *sem);
6)sem_timedwait函数 限时尝试对信号量加锁–
int sem_timedwait(sem_t *sem, const struct timespec *abs_timeout);2: abs_timeout采用的是绝对时间。

	e.g.定时1:
		time_t cur = time(NULL);获取当前时间。
		struct timespec t;定义timespec结构体变量tt.tv_sec = cur+1;定时1秒
		t.tv_nsec = t.tv_sec +100;
		sem_timedwait(&sem, &t);传参

2、生产者消费者信号量模型

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

  • 0
    点赞
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

贪睡的蜗牛

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值