2024年运维最全linux：生产者消费者模型，2024年最新真的太香了

最新推荐文章于 2024-06-14 17:37:13 发布

前端核心技术

最新推荐文章于 2024-06-14 17:37:13 发布

阅读量280

点赞数 4

分类专栏：程序员文章标签：运维 linux 服务器

本文链接：https://blog.csdn.net/m0_60388261/article/details/138635967

版权

程序员专栏收录该内容

165 篇文章 2 订阅

订阅专栏

为了做好运维面试路上的助攻手，特整理了上百道 【运维技术栈面试题集锦】 ，让你面试不慌心不跳，高薪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行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

三种关系：生产者与生产者之间(互斥)，消费者与消费者之间(互斥)，生产者与消费者之间(互斥 && 同步)
两种角色：生产者和消费者
一个交易(通讯)场所：一个容器(一段内存空间)

因为我们是多个线程访问同一个容器，那必然会导致数据不一致的问题，所以我们需要对该临界资源加锁，所以生产者与生产者之间，消费者与消费者之间，生产者与消费者之间都是互斥的。
又因为容器可能为空(满)，此时消费者(生产者)还一直在临界区申请锁，又因没有数据(空间)而释放锁，从而不断申请锁释放锁，导致生产者(消费者)的饥饿问题。此时我们就需要生产者与消费者之间的同步。

对于2,3两点，这很好理解不解释。
我们编写生产者消费者模型的本质就是对以上三点的维护。(互斥保证数据安全，同步保证效率)

优点：

解耦
支持并发
支持忙闲不均

对于第一点，不就是生产者与消费者通过容器来解耦提升效率(如果没有这个容器，则生产者生产完数据，就必须等待消费者来接受处理数据，不能立刻继续生产数据)。
对于第二点，当生产者在生产数据时，消费者也同时在处理数据
对于第三点，当生产者生产数据的速度超过消费者的处理能力时，容器可以起到缓存的作用，将多余的数据暂时存储，等待消费者有空闲时再进行处理。如果消费者处理数据的能力超过生产者时，同理。

二、基于阻塞队列的生产者消费者模型

在多线程编程中阻塞队列(Blocking Queue)是一种常用于实现生产者和消费者模型的数据结构。

队列为空时，从队列中取数据将被阻塞，直到队列中有数据时被唤醒。
队列为满时，向队列中放入数据将被阻塞，直到队列中有数据取出被唤醒。

代码实现

下面是一个单生成单消费模型
在这里插入图片描述
LockGuard.hpp 文件将加锁释放锁，交给一个对象处理，当对象创建加锁，对象销毁释放锁

#pragma once
#include <pthread.h>

class Mutex
{
public:
    Mutex(pthread_mutex_t \*mutex):\_mutex(mutex)
    {}

    void Lock()
    {
        pthread\_mutex\_lock(_mutex);
    }

    void UnLock()
    {
        pthread\_mutex\_unlock(_mutex);
    }

    ~Mutex()
    {}
private:
    pthread_mutex_t \*_mutex;
};

class LockGuard
{
public:
    LockGuard(pthread_mutex_t \*mutex): \_lock(mutex)
    {
        _lock.Lock();
    }

    ~LockGuard()
    {
        _lock.UnLock();
    }
private:
    Mutex _lock;
};

Blockqueue.hpp 文件

#pragma once
#include <iostream>
#include <queue>
#include <pthread.h>
#include "LockGuard.hpp"

using namespace std;
const int CAPACITY = 5;

template<class T>
class BlockQueue
{
public:
    BlockQueue(int cap = CAPACITY):\_capacity(cap)
    {
        pthread\_mutex\_init(&_mutex, nullptr);
        pthread\_cond\_init(&_p, nullptr);
        pthread\_cond\_init(&_c, nullptr);
    }

    bool isFull()
    {
        return _bq.size() == _capacity;
    }

    void Push(const T &in)
    {
        LockGuard mutex(&_mutex);
        //pthread\_mutex\_lock(&\_mutex);
        while(isFull())
        {
            pthread\_cond\_wait(&_p, &_mutex);
        }

        _bq.push(in);
        // 唤醒策略为 生产一个，消费一个
        pthread\_cond\_signal(&_c);

        //pthread\_mutex\_unlock(&\_mutex);
    }

    bool isEmpty()
    {
        return _bq.size() == 0;
    }

    void Pop(T \*out)
    {
        LockGuard mutex(&_mutex);
        //pthread\_mutex\_lock(&\_mutex);
        while(isEmpty())
        {
            pthread\_cond\_wait(&_c, &_mutex);
        }

        \*out = _bq.front();
        _bq.pop();
        // 唤醒策略为 消费一个，生产一个
        pthread\_cond\_signal(&_p);

        //pthread\_mutex\_unlock(&\_mutex);
    }

    ~BlockQueue()
    {
        pthread\_mutex\_destroy(&_mutex);
        pthread\_cond\_destroy(&_p);
        pthread\_cond\_destroy(&_c);
    }
private:
    queue<T> _bq;
    int _capacity;

    pthread_mutex_t _mutex;
    pthread_cond_t _p;
    pthread_cond_t _c;
};

Task.hpp 文件

#pragma once
#include <string>

const char \*opers = "+-\*/%";

enum
{
    ok = 0,
    div_zero,
    mod_zero
};

class Task
{
public:
    Task()
    {}

    Task(int x, int y, char op) : \_data\_x(x), \_data\_y(y), \_oper(op)
    {
        _code = ok;
    }

    void Run()
    {
        switch (_oper)
        {
        case '+':
            _result = _data_x + _data_y;
            break;
        case '-':
            _result = _data_x - _data_y;
            break;
        case '\*':
            _result = _data_x \* _data_y;
            break;
        case '/':
            {
                if(_data_y == 0)
                {
                    _code = div_zero;
                }
                else
                {
                    _result = _data_x / _data_y;
                }
            }
            break;
        case '%':
            {
                if(_data_y == 0)
                {
                    _code = mod_zero;
                }
                else
                {
                    _result = _data_x % _data_y;
                }
            }
            break;
        default:
            break;
        }
    }

    void operator()()
    {
        Run();
    }

    std::string PrintTask()
    {
        std::string ret = std::to\_string(_data_x);
        ret += _oper;
        ret += std::to\_string(_data_y);

        ret += "=?";
        return ret;
    }

    std::string PrintResult()
    {
        std::string ret = std::to\_string(_data_x);
        ret += _oper;
        ret += std::to\_string(_data_y);

        ret += "=";
        if(_code == ok)
        {
            ret += std::to\_string(_result);
        }
        else
        {
            ret += "?";
        }

        ret += "[";
        ret += std::to\_string(_code);
        ret += "]";

        return ret;
    }

    ~Task()
    {}

private:
    int _data_x;
    int _data_y;
    char _oper;

    int _result;
    int _code; // 错误码
};

Main.cc 文件

#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include <ctime>
#include <string.h>
#include "BlockQueue.hpp"
#include "Task.hpp"
using namespace std;


void \*producer(void \*args)
{
    BlockQueue<Task> \*bq = static\_cast<BlockQueue<Task> \*>(args);
    // 产生任务
    while (true)
    {
        int x = rand() % 10 + 1;
        int y = rand() % 10 + 1;
        char oper = opers[rand() % strlen(opers)];

        Task task(x, y, oper);
        cout << "producer: " << task.PrintTask() << endl;
        bq->Push(task);
        sleep(1);
    }

    return nullptr;
}

void \*consumer(void \*args)
{
    // usleep(1000);


为了做好运维面试路上的助攻手，特整理了上百道 **【运维技术栈面试题集锦】** ，让你面试不慌心不跳，高薪offer怀里抱！

这次整理的面试题，**小到shell、MySQL，大到K8s等云原生技术栈，不仅适合运维新人入行面试需要，还适用于想提升进阶跳槽加薪的运维朋友。**

![](https://img-blog.csdnimg.cn/img_convert/ac7fd08ed185bfe54a4f63d4547de24d.png)

本份面试集锦涵盖了

*   **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密码?

**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化的资料的朋友，可以点击这里获取！](https://bbs.csdn.net/forums/4f45ff00ff254613a03fab5e56a57acb)**

**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**

义？

> 10、什么叫CDN?

> 11、什么叫网站灰度发布?

> 12、简述DNS进行域名解析的过程?

> 13、RabbitMQ是什么东西?

> 14、讲一下Keepalived的工作原理?

> 15、讲述一下LVS三种模式的工作过程?

> 16、mysql的innodb如何定位锁问题，mysql如何减少主从复制延迟?

> 17、如何重置mysql root密码?

**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化的资料的朋友，可以点击这里获取！](https://bbs.csdn.net/forums/4f45ff00ff254613a03fab5e56a57acb)**

**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**

前端核心技术

关注

4
点赞
踩
6

收藏

觉得还不错? 一键收藏
0
评论
2024年运维最全linux：生产者消费者模型，2024年最新真的太香了

为了做好运维面试路上的助攻手，特整理了上百道，让你面试不慌心不跳，高薪offer怀里抱！这次整理的面试题，本份面试集锦涵盖了1、什么是运维?2、在工作中，运维人员经常需要跟运营人员打交道，请问运营人员是做什么工作的?3、现在给你三百台服务器，你怎么对他们进行管理?4、简述raid0 raid1raid5二种工作模式的工作原理及特点5、LVS、Nginx、HAproxy有什么区别?工作中你怎么选择?6、Squid、Varinsh和Nginx有什么区别，工作中你怎么选择?
复制链接

扫一扫