最后的话
最近很多小伙伴找我要Linux学习资料,于是我翻箱倒柜,整理了一些优质资源,涵盖视频、电子书、PPT等共享给大家!
资料预览
给大家整理的视频资料:
给大家整理的电子书资料:
如果本文对你有帮助,欢迎点赞、收藏、转发给朋友,让我有持续创作的动力!
网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。
一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!
我们发现可以安全得进行抢票,并不会出现抢到负数的票了
我们发现所有的线程都是通过同一个互斥量来实现互斥的,也就意味着这个互斥变量也是一个临界资源,大家都可以访问得到,所以互斥变量本身都不是安全的,那这样子如何保证别的线程的安全呢?其实设计互斥变量时就将它自身的计数器置为原子性操作
如果mutex是一个普通变量的情况,操作系统首先会将mutex的值加载到寄存器中,再判断寄存器中的值是否为1,如果为1就加锁,并将0写入到mutex中,然后访问临界资源,如果是0则让线程等到。但是在这个加锁并将0写到mutex中这个操作并非原子操作,如果时间片到了,mutex的值还是1,这时候会有其他线程进来加锁访问,会导致线程的不安全。
而情况并非这样,操作系统知道你是一个互斥变量,会先将寄存器的值置为0,然后直接将寄存器的值与内存中的mutex数据进行交换,这个交换操作是原子性操作(单条指令),这时候mutex的值肯定是0了,当有线程访问时肯定会是等待的了,然后再根据寄存器中的值进行判断是否可以加锁。加锁后再解锁,将mutex置回来
同步的实现
我们再来看看黄牛抢票的代码,如果我们打印线程的tid,也就是看哪个线程抢到的票
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
//票数
int ticket = 100;
//1、定义e互斥变量
pthread_mutex_t mutex;
//线程函数
void \*thr\_scalpers(void \*arg)
{
while (1)
{
//3、加锁一定是只加锁临界资源的访问
pthread\_mutex\_lock(&mutex);
if (ticket > 0)
{
usleep(1000);
printf("%p-i got a ticket:%d\n",pthread\_self(), ticket);
--ticket;
//4、解锁
pthread\_mutex\_unlock(&mutex);
}
else
{
//加锁后在任意有可能退出线程的地方都要解锁
pthread\_mutex\_unlock(&mutex);
pthread\_exit(NULL);
}
}
return NULL;
}
int main()
{
//4个线程
pthread_t tid[4];
int i, ret;
//2、互斥变量的初始化一定要放在线程创建之前
pthread\_mutex\_init(&mutex, NULL);
for (i = 0; i < 4; ++i)
{
//创建4个线程并执行
ret = pthread\_create(&tid[i], NULL, thr_scalpers, NULL);
if (ret != 0)
{
printf("thread create error");
return -1;
}
}
for (i = 0; i < 4; ++i)
{
pthread\_join(tid[i], NULL);
}
//5、一定要在所以线程不使用互斥变量后在销毁
pthread\_mutex\_destroy(&mutex);
return 0;
}
我们发现都是一个线程在执行,也就是说互斥并不保证资源分配的合理性,只保证了资源分配的安全性
条件变量
条件变量实现同步原理:是去判断当前线程是否满足获取资源的条件,当线程获取条件不满足的时候,调用阻塞接口,使线程阻塞,将pcb挂到等待队列上。等到条件满足的时候通过唤醒接口唤醒等待队列上的阻塞了的线程
条件变量提供了一个pcb等待队列,以及使线程阻塞的接口和唤醒线程的接口
条件的判断是用户进行的操作,判断线程是否满足条件,不满足的时候调用条件变量接口使线程等待
操作流程
- 定义条件变量
pthread_cond_t cond
- 初始化条件变量
pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *attr)
定义并初始化:pthread_cond_t cond = PTHREAD_COND_INITIALIZER
- 获取资源条件,不满足时挂起休眠
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)
这个接口是可以设置阻塞超时后可以自行唤醒 - 唤醒线程
pthread_cond_signal(pthread_cond_t *cond)
唤醒至少一个线程;pthread_cond_broadcast(pthread_cond_t *cond)
唤醒所有等待的线程 - 销毁条件变量
pthread_cond_destroy(pthread_cond_t *cond)
我们拿顾客和厨师来模拟实现同步的过程(保证资源利用合理性)
顾客(线程A) 厨师(线程B) 碗(资源)
顾客操作:
1、预定这个碗(加锁)
2、看碗是否有饭,没有饭就等着,把碗给厨师(访问资源前先判断是否满足访问条件,解锁,不满足就阻塞等待)
3、碗有饭,吃饭(加锁,满足访问条件,利用并占有该资源)
4、吃完后,奖励自己再来一碗(释放资源,唤醒另一个线程)
5、把碗还给厨师(解锁)
厨师操作:
1、把饭放到指定碗中(加锁)
2、看碗是否有饭,有饭就等着,把碗给顾客(访问资源前先判断是否满足访问条件,解锁,不满足就阻塞等待)
3、碗没有饭,做饭(加锁,满足访问条件,利用并占有该资源)
4、做完饭后叫顾客吃饭(释放资源,唤醒另一个线程)
5、把碗给客户(解锁)
代码实现
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <pthread.h>
//默认0表示碗中没有饭
int bowl = 0;
//实现线程间对bowl变量访问的同步操作
pthread_cond_t cond;
//保护bowl变量的访问操作
pthread_mutex_t mutex;
void \*thr\_cook(void \*arg)
{
while (1)
{
//加锁
pthread\_mutex\_lock(&mutex);
if (bowl != 0)//表示有饭,不满足做饭条件
{
//解锁,并让厨师线程等待,被唤醒后再加锁
//在该接口中解锁和休眠操作是一步完成的,保证操作的原子性
pthread\_cond\_wait(&cond, &mutex);//3步操作一个接口完成
}
bowl = 1;//能够走下来表示没饭,做完后置为1
printf("i made a bowl of rice\n");
//唤醒顾客吃饭
pthread\_cond\_signal(&cond);
//解锁
pthread\_mutex\_unlock(&mutex);
}
return NULL;
}
void \*thr\_customer(void \*arg)
{
while (1)
{
//加锁
pthread\_mutex\_lock(&mutex);
if (bowl != 1)//没有饭,不满足吃饭条件
{
//没有饭,先解锁,后等待
pthread\_cond\_wait(&cond, &mutex);
}
bowl = 0;//能够走下来表示有饭,吃完后置为0
printf("i had a bowl of rice, it was delicious\n");
//唤醒厨师做饭
pthread\_cond\_signal(&cond);
//解锁
pthread\_mutex\_unlock(&mutex);
}
return NULL;
}
int main()
{
//厨师线程
pthread_t cook_tid;
//顾客线程
pthread_t customer_tid;
int ret;
pthread\_mutex\_init(&mutex, NULL);
pthread\_cond\_init(&cond, NULL);
ret = pthread\_create(&cook_tid, NULL, thr_cook, NULL);
if (ret != 0)
{
printf("pthread\_create error\n");
return -1;
}
ret = pthread\_create(&customer_tid, NULL, thr_customer, NULL);
if (ret != 0)
{
printf("pthread\_create error\n");
return -1;
}
//等待厨师和顾客线程
pthread\_join(cook_tid, NULL);
pthread\_join(customer_tid, NULL);
pthread\_mutex\_destroy(&mutex);
pthread\_cond\_destroy(&cond);
return 0;
}
运行结果:我们发现通过同步与互斥,就可以实现对临界资源访问的安全性和合理性,不会出现没饭也吃的情况
但是如果存在多个顾客和多个厨师,会发生什么情况呢?
只提供修改主函数中的代码,其他代码和上面一样
int main()
{
//厨师线程
pthread_t cook_tid[4];
//顾客线程
pthread_t customer_tid[4];
int ret, i;
pthread\_mutex\_init(&mutex, NULL);
pthread\_cond\_init(&cond, NULL);
for (i = 0; i < 4; ++i){
ret = pthread\_create(&cook_tid[i], NULL, thr_cook, NULL);
if (ret != 0)
{
printf("pthread\_create error\n");
return -1;
}
}
for (i = 0; i < 4; ++i){
ret = pthread\_create(&customer_tid[i], NULL, thr_customer, NULL);
if (ret != 0)
{
printf("pthread\_create error\n");
return -1;
}
}
pthread\_join(cook_tid[0], NULL);
pthread\_join(customer_tid[0], NULL);
pthread\_mutex\_destroy(&mutex);
pthread\_cond\_destroy(&cond);
return 0;
}
运行结果:
我们发现,当存在多个顾客和多个厨师时,出现了没饭也吃,有饭也做的情况,这肯定不是我们想要的,那原因处在哪呢?
一开始有多个顾客线程,因为没有饭都进行等待,当一个厨师做好饭后,因为调用的是pthread_cond_signal
接口唤醒顾客,唤醒了至少1个顾客,也就是多个顾客,当有一个顾客加锁成功后,就去吃饭,剩下的顾客线程只能卡在加锁这里。加锁成功吃完饭的顾客线程去唤醒厨师并进行解锁,由于cpu是时间片调用线程的,加锁的不一定时厨师,有可能是卡在加锁那块的顾客线程,当顾客线程加锁后就去吃饭,但是此刻是没有饭的。所以就发生了错误如何避免这个错误呢?在第二步的条件判断应该改为循环判断,这样即使顾客加锁成功被唤醒后发现没饭也不会去吃了,而是看大没饭就继续休眠,有饭再吃
只提供修改两个线程入口函数的代码,其他代码和上面一样
void \*thr\_cook(void \*arg)
{
while (1)
{
//加锁
pthread\_mutex\_lock(&mutex);
while (bowl != 0)//表示有饭,不满足做饭条件
{
//解锁,并让厨师线程等待,被唤醒后再加锁
//在该接口中解锁和休眠操作是一步完成的,保证操作的原子性
pthread\_cond\_wait(&cond, &mutex);//3步操作一个接口完成
}
bowl = 1;//能够走下来表示没饭,做完后置为1
printf("i made a bowl of rice\n");
//唤醒顾客吃饭
pthread\_cond\_signal(&cond);
//解锁
pthread\_mutex\_unlock(&mutex);
}
return NULL;
}
void \*thr\_customer(void \*arg)
{
while (1)
{
//加锁
pthread\_mutex\_lock(&mutex);
while (bowl != 1)//没有饭,不满足吃饭条件
{
//没有饭,先解锁,后等待
pthread\_cond\_wait(&cond, &mutex);
}
bowl = 0;//能够走下来表示有饭,吃完后置为0
printf("i had a bowl of rice, it was delicious\n");
//唤醒厨师做饭
pthread\_cond\_signal(&cond);
//解锁
pthread\_mutex\_unlock(&mutex);
}
return NULL;
}
运行结果:
虽然不会出现没饭吃饭,有饭做饭的情况,但是我们发现程序发生了阻塞,不继续往下执行了,这又是什么原因呢?
条件变量只有一个,意味着等待队列只有一个,顾客没饭吃就挂到等待队列上,厨师不能做饭也要挂到等待队列上,假设一个厨师线程做完饭后,要去唤醒一个顾客线程去吃饭,但是却唤醒的是厨师线程(顾客线程和厨师线程都在同一个队列),唤醒的厨师线程发现有饭,又重新挂载等待队列中,从而导致程序阻塞如何避免这种情况呢?不同角色的线程应该在不同的等待队列上进行等待,这样等唤醒的时候,就不会唤醒同类型的线程了,因此存在多个角色线程,就应该设置多个条件变量(一个条件变量对应一个等待队列)
完整正确代码:
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <pthread.h>
//默认0表示碗中没有饭
int bowl = 0;
//实现线程间对bowl变量访问的同步操作
pthread_cond_t cook_cond;
pthread_cond_t customer_cond;
//保护bowl变量的访问操作
pthread_mutex_t mutex;
void \*thr\_cook(void \*arg)
{
while (1)
{
//加锁
pthread\_mutex\_lock(&mutex);
while (bowl != 0)//表示有饭,不满足做饭条件
{
//解锁,并让厨师线程等待,被唤醒后再加锁
//在该接口中解锁和休眠操作是一步完成的,保证操作的原子性
pthread\_cond\_wait(&cook_cond, &mutex);//3步操作一个接口完成
}
bowl = 1;//能够走下来表示没饭,做完后置为1
printf("i made a bowl of rice\n");
//唤醒顾客吃饭
pthread\_cond\_signal(&customer_cond);
//解锁
pthread\_mutex\_unlock(&mutex);
}
return NULL;
}
void \*thr\_customer(void \*arg)
{
while (1)
{
//加锁
pthread\_mutex\_lock(&mutex);
while (bowl != 1)//没有饭,不满足吃饭条件
{
//没有饭,先解锁,后等待
pthread\_cond\_wait(&customer_cond, &mutex);
}
bowl = 0;//能够走下来表示有饭,吃完后置为0
printf("i had a bowl of rice, it was delicious\n");
//唤醒厨师做饭
pthread\_cond\_signal(&cook_cond);
//解锁
pthread\_mutex\_unlock(&mutex);
}
return NULL;
}
int main()
{
//厨师线程
pthread_t cook_tid[4];
//顾客线程
pthread_t customer_tid[4];
int ret, i;
pthread\_mutex\_init(&mutex, NULL);
pthread\_cond\_init(&cook_cond, NULL);
pthread\_cond\_init(&customer_cond, NULL);
for (i = 0; i < 4; ++i){
ret = pthread\_create(&cook_tid[i], NULL, thr_cook, NULL);
if (ret != 0)
{
printf("pthread\_create error\n");
return -1;
}
}
for (i = 0; i < 4; ++i){
ret = pthread\_create(&customer_tid[i], NULL, thr_customer, NULL);
if (ret != 0)
{
printf("pthread\_create error\n");
return -1;
}
}
pthread\_join(cook_tid[0], NULL);
pthread\_join(customer_tid[0], NULL);
pthread\_mutex\_destroy(&mutex);
pthread\_cond\_destroy(&cook_cond);
pthread\_cond\_destroy(&customer_cond);
return 0;
}
运行结果:
使用注意事项总结:
1、条件变量需要搭配互斥锁一起使用
2、在每一个有可能退出线程的地方都需要解锁
3、条件变量使用时对条件的判断应该使用while循环来判断
4、多种角色线程应该使用多个条件变量
练习:生产者与消费者模型
信号量
信号量可以用于实现线程或者进程同步与互斥(主要用于同步)
信号量 = 一个计数器 + pcb等待队列
同步原理:通过自身计数器对资源进行计数,并通过计数器的资源计数,判断进程/线程是否能够符合访问资源的条件,若符合就可以访问,若不符合则调用提供的接口让进程/线程加入到pcb等待队列中;其他进程/线程促使条件满足之后,可以唤醒pcb等待队列上的进程/线程
为了做好运维面试路上的助攻手,特整理了上百道 【运维技术栈面试题集锦】 ,让你面试不慌心不跳,高薪offer怀里抱!
这次整理的面试题,小到shell、MySQL,大到K8s等云原生技术栈,不仅适合运维新人入行面试需要,还适用于想提升进阶跳槽加薪的运维朋友。
本份面试集锦涵盖了
- 174 道运维工程师面试题
- 128道k8s面试题
- 108道shell脚本面试题
- 200道Linux面试题
- 51道docker面试题
- 35道Jenkis面试题
- 78道MongoDB面试题
- 17道ansible面试题
- 60道dubbo面试题
- 53道kafka面试
- 18道mysql面试题
- 40道nginx面试题
- 77道redis面试题
- 28道zookeeper
总计 1000+ 道面试题, 内容 又全含金量又高
- 174道运维工程师面试题
1、什么是运维?
2、在工作中,运维人员经常需要跟运营人员打交道,请问运营人员是做什么工作的?
3、现在给你三百台服务器,你怎么对他们进行管理?
4、简述raid0 raid1raid5二种工作模式的工作原理及特点
5、LVS、Nginx、HAproxy有什么区别?工作中你怎么选择?
6、Squid、Varinsh和Nginx有什么区别,工作中你怎么选择?
7、Tomcat和Resin有什么区别,工作中你怎么选择?
8、什么是中间件?什么是jdk?
9、讲述一下Tomcat8005、8009、8080三个端口的含义?
10、什么叫CDN?
11、什么叫网站灰度发布?
12、简述DNS进行域名解析的过程?
13、RabbitMQ是什么东西?
14、讲一下Keepalived的工作原理?
15、讲述一下LVS三种模式的工作过程?
16、mysql的innodb如何定位锁问题,mysql如何减少主从复制延迟?
17、如何重置mysql root密码?
网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。
一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!
7、Tomcat和Resin有什么区别,工作中你怎么选择?
8、什么是中间件?什么是jdk?
9、讲述一下Tomcat8005、8009、8080三个端口的含义?
10、什么叫CDN?
11、什么叫网站灰度发布?
12、简述DNS进行域名解析的过程?
13、RabbitMQ是什么东西?
14、讲一下Keepalived的工作原理?
15、讲述一下LVS三种模式的工作过程?
16、mysql的innodb如何定位锁问题,mysql如何减少主从复制延迟?
17、如何重置mysql root密码?
网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。
一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!