正文

C++面试必看：掌握这些高并发编程题，轻松应对面试挑战

/0 浏览量
1016

在C++面试中，高并发编程是一个常见且重要的考察点。掌握以下高并发编程题目，可以帮助你在面试中脱颖而出，轻松应对挑战。本文将详细介绍这些题目，并辅以示例代码，让你更好地理解和应用。

1. 线程同步

线程同步是高并发编程的基础，以下是一些常见的线程同步问题：

1.1 互斥锁（Mutex）

问题：请实现一个互斥锁，并演示其使用方法。

示例代码：

#include <iostream>
#include <mutex>

std::mutex mtx;

void printHello() {
    mtx.lock();
    std::cout << "Hello World" << std::endl;
    mtx.unlock();
}

int main() {
    std::thread t1(printHello);
    std::thread t2(printHello);
    t1.join();
    t2.join();
    return 0;
}

1.2 条件变量（Condition Variable）

问题：请实现一个生产者-消费者模型，使用条件变量实现线程间的同步。

示例代码：

#include <iostream>
#include <mutex>
#include <condition_variable>
#include <queue>
#include <thread>

std::mutex mtx;
std::condition_variable cv;
std::queue<int> queue;

void producer() {
    for (int i = 0; i < 10; ++i) {
        std::unique_lock<std::mutex> lock(mtx);
        queue.push(i);
        std::cout << "Produced " << i << std::endl;
        lock.unlock();
        cv.notify_one();
    }
}

void consumer() {
    while (true) {
        std::unique_lock<std::mutex> lock(mtx);
        cv.wait(lock, []{return !queue.empty();});
        int value = queue.front();
        queue.pop();
        std::cout << "Consumed " << value << std::endl;
        lock.unlock();
    }
}

int main() {
    std::thread t1(producer);
    std::thread t2(consumer);
    t1.join();
    t2.join();
    return 0;
}

2. 线程池

线程池是一种常用的并发编程模式，以下是一些线程池相关的题目：

2.1 线程池的基本原理

问题：请解释线程池的基本原理，并实现一个简单的线程池。

示例代码：

#include <iostream>
#include <vector>
#include <thread>
#include <queue>
#include <mutex>
#include <condition_variable>

std::queue<std::function<void()>> tasks;
std::mutex mtx;
std::condition_variable cv;
bool done = false;

void worker() {
    while (true) {
        std::function<void()> task;
        {
            std::unique_lock<std::mutex> lock(mtx);
            cv.wait(lock, []{return !tasks.empty() || done;});
            if (done && tasks.empty()) {
                return;
            }
            task = std::move(tasks.front());
            tasks.pop();
        }
        task();
    }
}

void addTask(std::function<void()> task) {
    std::unique_lock<std::mutex> lock(mtx);
    tasks.push(task);
    cv.notify_one();
}

int main() {
    std::vector<std::thread> threads;
    for (int i = 0; i < 4; ++i) {
        threads.emplace_back(worker);
    }
    for (int i = 0; i < 10; ++i) {
        addTask([i]{
            std::cout << "Task " << i << std::endl;
        });
    }
    {
        std::unique_lock<std::mutex> lock(mtx);
        done = true;
    }
    cv.notify_all();
    for (auto& t : threads) {
        t.join();
    }
    return 0;
}

3. 并发数据结构

并发数据结构是高并发编程中的重要组成部分，以下是一些常见的并发数据结构：

3.1 读写锁（Read-Write Lock）

问题：请实现一个读写锁，并演示其使用方法。

示例代码：

#include <iostream>
#include <mutex>

class ReadWriteLock {
public:
    void lockRead() {
        std::unique_lock<std::mutex> lock(mtx);
        read_count++;
        if (read_count == 1) {
            write_mutex.lock();
        }
    }

    void unlockRead() {
        std::unique_lock<std::mutex> lock(mtx);
        read_count--;
        if (read_count == 0) {
            write_mutex.unlock();
        }
    }

    void lockWrite() {
        write_mutex.lock();
    }

    void unlockWrite() {
        write_mutex.unlock();
    }

private:
    std::mutex mtx;
    std::mutex write_mutex;
    int read_count = 0;
};

void read() {
    rw.lockRead();
    std::cout << "Reading..." << std::endl;
    rw.unlockRead();
}

void write() {
    rw.lockWrite();
    std::cout << "Writing..." << std::endl;
    rw.unlockWrite();
}

int main() {
    ReadWriteLock rw;
    std::thread t1(read);
    std::thread t2(read);
    std::thread t3(write);
    t1.join();
    t2.join();
    t3.join();
    return 0;
}

通过学习和掌握以上高并发编程题目，相信你在C++面试中能够更加从容应对。祝你面试顺利！

-- 展开阅读全文 --