C++造轮子飙车现场之无锁、有锁环形队列实现

先看带锁的实现。

带锁版本

circular_queue.h

// 头文件防卫
#ifndef CIRCULAR_QUEUE_H
#define CIRCULAR_QUEUE_H

#include <mutex> // 互斥量
#include <condition_variable> // 条件变量

template <typename T>
class CircularQueue {
public:
    // 构造函数,初始化成员变量
    explicit CircularQueue(size_t capacity) :
        capacity_(capacity),
        size_(0),
        head_(0),
        tail_(0),
        buffer_(new T[capacity]) {}

    // 析构函数,释放 buffer_ 内存
    ~CircularQueue() {
        delete[] buffer_;
    }

    // 判断队列是否为空
    bool empty() {
        std::unique_lock<std::mutex> lock(mutex_);
        return size_ == 0;
    }

    // 判断队列是否已满
    bool full() {
        std::unique_lock<std::mutex> lock(mutex_);
        return size_ == capacity_;
    }

    // 获取队列中元素的数量
    size_t size() {
        std::unique_lock<std::mutex> lock(mutex_);
        return size_;
    }

    // 获取队列的容量
    size_t capacity() {
        return capacity_;
    }

    // 将元素加入队列,可能会阻塞
    bool push(const T& value, bool block = true) {
        std::unique_lock<std::mutex> lock(mutex_);

        if (block) {
            // 如果队列已满,则等待队列不满
            while (size_ == capacity_) {
                not_full_.wait(lock);
            }
        } else {
            // 如果队列已满,则返回 false
            if (size_ == capacity_) {
                return false;
            }
        }

        // 将元素加入队列尾部,并更新 tail_ 和 size_
        buffer_[tail_] = value;
        tail_ = (tail_ + 1) % capacity_;
        ++size_;

        // 通知一个等待在 not_empty_ 条件变量上的线程
        not_empty_.notify_one();

        return true;
    }

    // 将元素加入队列,可能会阻塞,使用右值引用
    bool push(T&& value, bool block = true) {
        std::unique_lock<std::mutex> lock(mutex_);

        if (block) {
            // 如果队列已满,则等待队列不满
            while (size_ == capacity_) {
                not_full_.wait(lock);
            }
        } else {
            // 如果队列已满,则返回 false
            if (size_ == capacity_) {
                return false;
            }
        }

        // 将元素加入队列尾部,并更新 tail_ 和 size_
        buffer_[tail_] = std::move(value);
        tail_ = (tail_ + 1) % capacity_;
        ++size_;

        // 通知一个等待在 not_empty_ 条件变量上的线程
        not_empty_.notify_one();

        return true;
    }

    // 从队列中取出元素,可能会阻塞
    bool pop(T& value, bool block = true) {
        std::unique_lock<std::mutex> lock(mutex_);

        if (block) {
            // 如果队列为空,则等待队列不空
            while (size_ == 0) {
                not_empty_.wait(lock);
            }
        } else {
            // 如果队列为空,则返回 false
            if (size_ == 0) {
                return false;
            }
        }

        // 取出队列头部元素,并更新 head_ 和 size_
        value = std::move(buffer_[head_]);
        head_ = (head_ + 1) % capacity_;
        --size_;

        // 通知一个等待在 not_full_ 条件变量上的线程
        not_full_.notify_one();

        return true;
    }

private:
    const size_t capacity_; // 队列容量
    size_t size_; // 队列中元素的数量
    size_t head_; // 队列头部指针
    size_t tail_; // 队列尾部指针
    T* buffer_; // 队列缓冲区    
    std::mutex mutex_; // 互斥量,保护队列缓冲区和队列大小
    std::condition_variable not_full_; // 条件变量,当队列满时等待
    std::condition_variable not_empty_; // 条件变量,当队列空时等待
};

#endif // CIRCULAR_QUEUE_H

push和pop接口不指定第二个参数的话,默认是阻塞的,这一点使用时需要注意。

以下是CircularQueue类的单元测试示例代码:

#include <gtest/gtest.h>
#include <thread>
  
#include "circular_queue.h"

TEST(CircularQueueTest, EmptyQueue) {
    CircularQueue<int> queue(10);
    ASSERT_TRUE(queue.empty());
    ASSERT_FALSE(queue.full());
    ASSERT_EQ(queue.size(), 0);
    ASSERT_EQ(queue.capacity(), 10);
}

TEST(CircularQueueTest, PushAndPop) {
    CircularQueue<int> queue(3);

    ASSERT_TRUE(queue.push(1));
    ASSERT_EQ(queue.size(), 1);
    ASSERT_FALSE(queue.empty());
    ASSERT_FALSE(queue.full());

    ASSERT_TRUE(queue.push(2));
    ASSERT_EQ(queue.size(), 2);
    ASSERT_FALSE(queue.empty());
    ASSERT_FALSE(queue.full());

    ASSERT_TRUE(queue.push(3));
    ASSERT_EQ(queue.size(), 3);
    ASSERT_FALSE(queue.empty());
    ASSERT_TRUE(queue.full());

    int value;
    ASSERT_TRUE(queue.pop(value));
    ASSERT_EQ(value, 1);
    ASSERT_EQ(queue.size(), 2);
    ASSERT_FALSE(queue.empty());
    ASSERT_FALSE(queue.full());

    ASSERT_TRUE(queue.pop(value));
    ASSERT_EQ(value, 2);
    ASSERT_EQ(queue.size(), 1);
    ASSERT_FALSE(queue.empty());
    ASSERT_FALSE(queue.full());

    ASSERT_TRUE(queue.pop(value));
    ASSERT_EQ(value, 3);
    ASSERT_EQ(queue.size(), 0);
    ASSERT_TRUE(queue.empty());
    ASSERT_FALSE(queue.full());

    ASSERT_FALSE(queue.pop(value,false));
}

TEST(CircularQueueTest, PushAndPopWithBlocking) {
    CircularQueue<int> queue(2);

    std::thread t([&queue]() {
        int value = 0;
        queue.pop(value);
        ASSERT_EQ(value, 1);
        queue.pop(value);
        ASSERT_EQ(value, 2);
    });

    ASSERT_TRUE(queue.push(1));
    ASSERT_TRUE(queue.push(2));
    ASSERT_TRUE(queue.push(3));

    t.join();
}

TEST(CircularQueueTest, PushAndPopWithNonBlocking) {
    CircularQueue<int> queue(2);

    int value;
    ASSERT_TRUE(queue.push(1));
    ASSERT_TRUE(queue.push(2));
    ASSERT_FALSE(queue.push(3, false));
    ASSERT_TRUE(queue.pop(value));
    ASSERT_EQ(value, 1);
    ASSERT_TRUE(queue.pop(value));
    ASSERT_EQ(value, 2);
    ASSERT_FALSE(queue.pop(value, false));
}

TEST(CircularQueueTest, MovePushAndPop) {
    CircularQueue<std::string> queue(3);

    ASSERT_TRUE(queue.push("hello"));
    ASSERT_TRUE(queue.push("world"));
    ASSERT_EQ(queue.size(), 2);

    std::string value;
    ASSERT_TRUE(queue.pop(value));
    ASSERT_EQ(value, "hello");
    ASSERT_EQ(queue.size(), 1);

    ASSERT_TRUE(queue.push("foo"));
    ASSERT_EQ(queue.size(), 2);

    ASSERT_TRUE(queue.pop(value));
    ASSERT_EQ(value, "world");
    ASSERT_EQ(queue.size(), 1);

    ASSERT_TRUE(queue.pop(value));
    ASSERT_EQ(value, "foo");
    ASSERT_EQ(queue.size(), 0);
}

TEST(CircularQueueTest, CopyPushAndPop) {
    CircularQueue<std::string> queue(3);

    ASSERT_TRUE(queue.push(std::string("hello")));
    ASSERT_TRUE(queue.push(std::string("world")));
    ASSERT_EQ(queue.size(), 2);

    std::string value;
    ASSERT_TRUE(queue.pop(value));
    ASSERT_EQ(value, "hello");
    ASSERT_EQ(queue.size(), 1);

    ASSERT_TRUE(queue.push(std::string("foo")));
    ASSERT_EQ(queue.size(), 2);

    ASSERT_TRUE(queue.pop(value));
    ASSERT_EQ(value, "world");
    ASSERT_EQ(queue.size(), 1);

    ASSERT_TRUE(queue.pop(value));
    ASSERT_EQ(value, "foo");
    ASSERT_EQ(queue.size(), 0);
}

TEST(CircularQueueTest, MultiThreadPushPop) {
    const int num_threads = 4;
    const int num_iterations = 10000;
    const int queue_size = 100;

    CircularQueue<int> queue(queue_size);

    std::vector<std::thread> threads;

    for (int i = 0; i < num_threads; ++i) {
        threads.emplace_back([&queue, num_iterations]() {
            for (int j = 0; j < num_iterations; ++j) {
                queue.push(j);
            }
        });
    }

    for (int i = 0; i < num_threads; ++i) {
        threads.emplace_back([&queue, num_iterations]() {
            for (int j = 0; j < num_iterations; ++j) {
                int value;
                queue.pop(value);
            }
        });
    }

    for (auto& thread : threads) {
        thread.join();
    }

    ASSERT_EQ(queue.size(), 0);
}

int main(int argc, char** argv) {
    testing::InitGoogleTest(&argc, argv);
    return RUN_ALL_TESTS();
}

单元测试运行结果:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CqCh8DqE-1679157650605)(C:\Users\小静静\AppData\Roaming\Typora\typora-user-images\image-20230319001514719.png)]

无锁版本

上面的循环队列使用锁保证了线程安全。

以下是一个基于C++11的线程安全且无锁的环形队列实现,支持阻塞读和非阻塞读,写也一样。

#include <atomic>
#include <condition_variable>
#include <functional>
#include <iostream>
#include <thread>
#include <vector>

template <typename T, size_t N>
class RingQueue {
public:
    RingQueue() : read_idx_(0), write_idx_(0), data_{} {}

    bool Push(const T& item, bool block = false) { return PushImpl(item, block); }
    bool Push(T&& item, bool block = false) { return PushImpl(std::move(item), block); }

    bool Pop(T& item, bool block = false) {
        // 只有一个读者,read_idx_的读取可以不加锁
        size_t current_read_idx = read_idx_.load(std::memory_order_relaxed);
   
		// 保证读到write_idx_的变化,此处memory_order_acquire发挥的是可见性问题
        while (current_read_idx == write_idx_.load(std::memory_order_acquire)) {
        	if (!block) {
        		return false;
      		}
      		std::this_thread::yield();
        }

        item = std::move(data_[current_read_idx]); // 必须先把数据读走read_idx_才能+1,memory_order_release保证了对item的写不会被重排到read_idx_ + 1之后
        read_idx_.store(Next(current_read_idx), std::memory_order_release);

        return true;
    }

    template <typename Func>
    bool Pop(Func&& func, bool block = false) {
        size_t current_read_idx = read_idx_.load(std::memory_order_relaxed);

        while (current_read_idx == write_idx_.load(std::memory_order_acquire)) {
        	if (!block) {
        		return false;
      		}
      		std::this_thread::yield();
        }

        T item = std::move(data_[current_read_idx]);
        read_idx_.store(Next(current_read_idx), std::memory_order_release);

        func(std::move(item));

        return true;
    }

    void PopAsync(const T& value, std::function<void(bool)> callback) {
       auto task = [this, value, callback]() {
       	 bool result = Pop(value, true);
         callback(result);
       };
       std::thread(std::move(task)).detach();
    }    
    
    bool IsEmpty() const {
        return read_idx_.load(std::memory_order_acquire) ==
               write_idx_.load(std::memory_order_acquire);
    }

    bool IsFull() const {
        return Next(write_idx_.load(std::memory_order_acquire)) ==
               read_idx_.load(std::memory_order_acquire);
    }

private:
    template <typename Item>
    bool PushImpl(Item&& item, bool block = false) {
        // 只有1个写线程, 所以write_idx_可以不加锁
        size_t current_write_idx = write_idx_.load(std::memory_order_relaxed);
        size_t next_write_idx = Next(current_write_idx);

        // 读线程会修改read_idx_, 所以此处需要保证看到read_idx_的变化,此处memory_order_acquire保证的是可见性问题
        while (next_write_idx == read_idx_.load(std::memory_order_acquire)) {
            if(!block) {
                return false;
            }
            std::this_thread::yield();
        }

        // 数据的写入必须在write_idx_+1之前
        data_[current_write_idx] = std::forward<Item>(item);
        
        // 保证之前的写操作对读线程可见,即读线程能立刻看到data_刚写入的数据,当然也包括write_idx_的+1变化,memory_order_release会保证对data_的写入在write_idx_+1的操作之前完成。
        // 因为就算data_的赋值语句放在write_idx_+1之前,由于编译器或者运行期指令重排,并不一定能保证data_赋值语句就一定在write_idx_+1前执行。
        write_idx_.store(next_write_idx, std::memory_order_release);

        return true;
    }

    size_t Next(size_t current_idx) const { return (current_idx + 1) % (N+1); } // 此处笔者做了修改,N改成N+1

    std::atomic<size_t> read_idx_;
    std::atomic<size_t> write_idx_;
    std::array<T, N+1> data_;  // 此处笔者做了修改,N改成N+1
};

代码中使用了模板参数T和N,支持了不同数据类型和不同队列大小的选择,借助读写指针两个原子变量实现无锁环形队列。

但需要注意的是,这个只能实现一读一写的线程安全,存在多个读者或者多个写者时就线程不安全了。

无锁编程的难点在于对几个内存时序的理解。

补充下关于内存时序操作的解释。

C++定义了几种内存时序,这些时序规定了原子变量前后的所有内存操作(包括普通变量、原子变量)如何排序

std::memory_order_relaxed只保正操作的原子性,对于同一个原子变量的多个操作之间不存在任何内存序的限制,也就是说,它们可以随意重排序,也可以在任意时刻被其他线程的操作所干扰。因此,使用std::memory_order_relaxed时需要特别小心,必须确保操作的正确性不受此种松散的内存访问顺序的影响。

std::memory_order_relaxed主要用于那些不需要任何同步机制的场合,比如计数器的自增、自减等操作,这些操作只需要保证结果的正确性,而不需要保证其执行的顺序。因此,std::memory_order_relaxed是最快的内存序,但也是最危险的一种内存序。


std::memory_order_acquire确保所有之前的读操作都已经完成,然后再执行当前读取操作。这意味着,如果当前读取操作需要用到之前的读取操作的结果,那么它将能够正确地获取到这些结果。

具体来说,当使用memory_order_acquire语义时,编译器和处理器都会保证当前线程所在的CPU核心(或处理器)在执行当前原子操作之前,会先将所有之前的读操作所获得的数据从CPU缓存中刷新到主内存中,以保证当前线程能够读取到其他线程对共享变量的最新修改。

使用memory_order_acquire语义可以保证程序的正确性,避免出现数据竞争的问题。但是,使用memory_order_acquire语义可能会降低程序的性能,因为它要求在执行原子操作之前,必须将所有之前的读操作都刷新到主内存中,这可能会导致缓存一致性协议的开销增加。因此,在实际编程中,应该根据具体情况选择合适的内存序语义。


std::memory_order_release确保当前线程的所有写操作在该原子操作之前都已经完成,并且将这些写操作对其他线程可见。这样,其他线程就可以看到当前线程对共享数据所做的更改。

这种释放操作通常用于同步操作,例如将一个共享变量的值更新后通知其他线程。在这种情况下,std::memory_order_release可以确保其他线程能够看到更新后的值。

Push提供了插入左值和右值两个版本,提高C++所谓的一点点性能,PushImpl提取了公共代码,实现代码复用,优雅!。

Pop提供了两个版本,有个变体,不返回pop出来的对象,而是调用外部传入的回调,对pop出来的对象进行操作。

同样附上单元测试。

#include <gtest/gtest.h>
#include "RingQueue.h"

class RingQueueSingleThreadTest : public ::testing::Test {
protected:
    RingQueue<int, 10> queue_;
};

TEST_F(RingQueueSingleThreadTest, PushAndPop) {
    int value = 0;
    EXPECT_FALSE(queue_.Pop(value));
    EXPECT_TRUE(queue_.Push(1));
    EXPECT_FALSE(queue_.IsEmpty());
    EXPECT_TRUE(queue_.Pop(value));
    EXPECT_EQ(value, 1);
    EXPECT_TRUE(queue_.IsEmpty());
}

TEST_F(RingQueueSingleThreadTest, PushAndPopWithBlock) {
    int value = 0;
    std::thread t([&](){
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
        queue_.Push(1, true);
    });
    EXPECT_TRUE(queue_.Pop(value, true));
    EXPECT_EQ(value, 1);
    t.join();
}

TEST_F(RingQueueSingleThreadTest, PushAndPopWithFunc) {
    int value = 0;
    queue_.Push(1);
    queue_.Pop([&](int v){ value = v + 1; });
    EXPECT_EQ(value, 2);
}

TEST_F(RingQueueSingleThreadTest, IsEmptyAndIsFull) {
    EXPECT_TRUE(queue_.IsEmpty());
    EXPECT_FALSE(queue_.IsFull());
    for (int i = 0; i < 10; ++i) {
        EXPECT_TRUE(queue_.Push(i));
    }
    EXPECT_TRUE(queue_.IsFull());
    EXPECT_FALSE(queue_.IsEmpty());
    int value = 0;
    EXPECT_FALSE(queue_.Push(10));
    EXPECT_TRUE(queue_.Pop(value));
    EXPECT_FALSE(queue_.IsFull());
}

class RingQueueMultiThreadTest : public testing::Test {
protected:
    virtual void SetUp() {
        // 初始化数据
        for (int i = 0; i < 1000; ++i) {
            data_.push_back("data_" + std::to_string(i));
        }
    }

    std::vector<std::string> data_;
};

TEST_F(RingQueueMultiThreadTest, MultiThreadTest) {
    RingQueue<std::string, 10> queue;

    // 写线程
    std::thread writer([&queue, this]() {
        for (const auto& item : data_) {
            queue.Push(item, true);
        }
    });

    // 读线程
    std::thread reader([&queue, this]() {
        int count = 0;
        std::string item;
        while (count < 1000) {
            if (queue.Pop(item, true)) {
                EXPECT_EQ(item, "data_" + std::to_string(count));
                ++count;
            } else {
                std::this_thread::yield();
            }
        }
    });

    writer.join();
    reader.join();
}

int main(int argc, char** argv) {
    ::testing::InitGoogleTest(&argc, argv);
    return RUN_ALL_TESTS();
}

在这里插入图片描述

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:/a/1572.html

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

公司测试员用例写得乱七八糟,测试总监制定了这份《测试用例编写规范》

统一测试用例编写的规范&#xff0c;为测试设计人员提供测试用例编写的指导&#xff0c;提高编写的测试用例的可读性&#xff0c;可执行性、合理性。为测试执行人员更好执行测试&#xff0c;提高测试效率&#xff0c;最终提高公司整个产品的质量。 一、范围 适用于集成测试用…

vue3 项目搭建教程(基于create-vue,vite,Vite + Vue)

vue3 项目搭建教程&#xff08;基于create-vue&#xff0c;vite&#xff0c;Vite Vue&#xff09; 目录 一、搭建vue3 项目前提条件 二、通过create-vue搭建vue3 项目 三、搭建一个 Vite 项目 四、构建一个 Vite Vue 项目 五、打开Vue 项目管理器 六、Vite Vue 项目目…

云开发--实现发送邮件+短信+链接跳转小程序功能

目录 1、小程序实现发送邮件 准备一个qq邮箱&#xff0c;并启动SMTP服务 确定小程序云开发环境&#xff0c;并新建云函数 2、小程序实现发送短信 确定应用 确定签名 确定模板 编写云函数-发送短信 3、链接跳转小程序 H5 配置 生成 URL Link 学习记录&#xff1a; …

【洛谷刷题】蓝桥杯专题突破-深度优先搜索-dfs(4)

目录 写在前面&#xff1a; 题目&#xff1a;P1149 [NOIP2008 提高组] 火柴棒等式 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn) 题目描述&#xff1a; 输入格式&#xff1a; 输出格式&#xff1a; 输入样例&#xff1a; 输出样例&#xff1a; 解题思路&#xff1a; …

Java进阶2 排序查找与Lambda、正则表达式

排序查找与Lambda、正则表达式● 导图一、 基础算法1.排序1.1 冒泡排序1.2 选择排序2. 查找2.1 基础查找2.2 二分查找二、Lambda表达式1&#xff09;初识Lambda2&#xff09;函数式编程3&#xff09;.Lambda表达式的标准格式4&#xff09;Lambda的注意事项5&#xff09;Lambda表…

k8s 1.18.20版本部署

身为k8s初学者&#xff0c;在掌握k8s理论知识的同时&#xff0c;也需要掌握一下实际部署k8s的过程&#xff0c;对于理论的学习起到一定的帮助作用。罗列了一下相关步骤&#xff0c;请各位参考&#xff1a; 一、环境准备 三台虚机&#xff1a; 操作系统&#xff1a; CentOS L…

【计算机组成原理 - 第二章】系统总线(完结)

本章参考王道考研相关课程&#xff1a; 【2019版】6.1.1 总线的概念与分类_哔哩哔哩_bilibili 【2019版】6.1.2 总线的性能指标_哔哩哔哩_bilibili 【2019版】6.2 总线仲裁_哔哩哔哩_bilibili 【2019版】6.3 总线操作和定时_哔哩哔哩_bilibili 【2019版】6.4 总线标准_哔哩哔哩…

Mac 和 Win,到底用哪个系统学编程?

今天来聊一个老生常谈的问题&#xff0c;学编程时到底选择什么操作系统&#xff1f;Mac、Windows&#xff0c;还是别的什么。。 作为一个每种操作系统都用过很多年的程序员&#xff0c;我会结合我自己的经历来给大家一些参考和建议。 接下来先分别聊聊每种操作系统的优点和不…

springCloud学习【2】之Nacnos配置管理Fegin远程调用gateway服务网关

文章目录前言一 Nacos配置管理1.1 统一配置管理1.1.1 nacos中添加配置文件1.1.2 从微服务拉取配置1.2 配置热更新1.2.1 方式一&#xff1a;添加注解RefreshScope1.2.2 方式二&#xff1a;使用ConfigurationProperties注解1.3 配置共享二 搭建Nacos集群2.1 集群结构图2.2 搭建集…

【函数】JavaScript 全栈体系(七)

JavaScript 基础 第十三章 函数 一、为什么需要函数 函数&#xff1a; function&#xff0c;是被设计为执行特定任务的代码块 说明&#xff1a; 函数可以把具有相同或相似逻辑的代码“包裹”起来&#xff0c;通过函数调用执行这些被“包裹”的代码逻辑&#xff0c;这么做…

cv2报错:Unsupported depth of input image

cv2 报错 error: OpenCV(4.6.0) /io/opencv/modules/imgproc/src/color.simd_helpers.hpp:94: error: (-2:Unspecified error) in function ‘cv::impl::{anonymous}::CvtHelper<VScn, VDcn, VDepth, sizePolicy>::CvtHelper(cv::InputArray, cv::OutputArray, int) [wit…

vue后台管理系统——添加i18n国际化功能——技能提升

昨天在写后台管理系统时&#xff0c;遇到一个需求就是需要实现国际化功能。 antd和element-ui这两个框架其实都是有国际化的。 具体展示形式就是如下&#xff1a; 点击右上角头部的语言&#xff0c;切换语言&#xff0c;然后整个系统的文字都改变成对应的语言展示。 切换成…

燕山大学-面向对象程序设计实验-实验7 多态性:函数与运算符重载-实验报告

CSDN的各位友友们你们好,今天千泽为大家带来的是燕山大学-面向对象程序设计实验-实验5 派生与继承&#xff1a;单重派生-实验报告,接下来让我们一起进入c的神奇小世界吧,相信看完你也能写出自己的 实验报告!本系列文章收录在专栏 燕山大学面向对象设计报告中 ,您可以在专栏中找…

【C语言进阶】内存函数

天生我材必有用&#xff0c;千金散尽还复来。 ——李白 目录 前言 一.memcpy函数 ​1.实现memcpy函数 2.模拟实现memcpy函数 二.memmove函数 1.实现memmove函数 2.模拟实现memmove函数 三.memcpy函数和memmove函数的关系 四.memcm…

2023金三银四--我们遇到的那些软件测试面试题【功能/接口/自动化/性能等等】

一、面试技巧题(主观题) 序号面试题1怎么能在技术没有那么合格的前提下给面试官留个好印象&#xff1f;2面试时&#xff0c;如何巧妙地避开不会的问题&#xff1f;面试遇到自己不会的问题如何机智的接话&#xff0c;化被动为主动&#xff1f;3对于了解程度的技能&#xff0c;被…

【Docker】什么是Docker?Docker的安装、加速

文章目录Docker出现的背景解决问题docker理念容器与虚拟机比较容器发展简史传统虚拟机技术容器虚拟化技术Docker安装官方网站安装前提Docker的基本组成镜像容器仓库Docker平台架构图解CentOS7安装Docker确定你是CentOS7及以上版本卸载旧版本yum安装gcc相关安装需要的软件包设置…

用 ChatGPT 辅助学好机器学习

文章目录一、前言二、主要内容&#x1f349; CSDN 叶庭云&#xff1a;https://yetingyun.blog.csdn.net/ 一、前言 探索更高效的学习方法可能是有志者共同的追求&#xff0c;用好 ChatGPT&#xff0c;先行于未来。 作为一个人工智能大语言模型&#xff0c;ChatGPT 可以在帮助初…

Pandas 与 PySpark 强强联手,功能与速度齐飞

Pandas做数据处理可以说是yyds&#xff01;而它的缺点也是非常明显&#xff0c;Pandas 只能单机处理&#xff0c;它不能随数据量线性伸缩。例如&#xff0c;如果 pandas 试图读取的数据集大于一台机器的可用内存&#xff0c;则会因内存不足而失败。 另外 pandas 在处理大型数据…

Linux分文件编程:静态库与动态库的生成和使用

目录 一&#xff0c;Linux库引入之分文件编程 ① 简单说明 ② 分文件编程优点 ③ 操作逻辑 ④ 代码实现说明 二&#xff0c;Linux库的基本说明 三&#xff0c;Linux库之静态库的生成与使用 ① 静态库命名规则 ② 静态库制作步骤 ③ 静态库的使用 四&#xff0c;Linu…

django-celery-beat搭建定时任务

一、创建django项目和app 1、安装定时任务第三方包 pip install django-celery-beat # 插件用来动态配置定时任务,一般会配合 django_celery_results 一起使用&#xff0c;所以一起安装 django_celery_results pip install django_celery_results pip install eventlet # win…