C++ 面试手撕

手搓线程池

#ifndef __THREADPOOL_H__
#define __THREADPOOL_H__

#include <thread>
#include <memory>
#include <condition_variable>
#include <mutex>
#include <functional>
#include <queue>

class ThreadPool {
public:
    explicit ThreadPool(size_t number = 6) : pool_(std::make_shared<Pool>()) {
        for (size_t i = 0; i < number; ++i) {
            std::thread([pool = pool_] {
                std::unique_lock<std::mutex> lock(pool->mtx);
                while (true) {
                    if (!pool->tasks.empty()) {
                        auto task = std::move(pool->tasks.front());
                        pool->tasks.pop();
                        lock.unlock();
                        task();
                        lock.lock();
                    } else if (pool->isClosed) {
                        break;
                    } else {
                        pool->cond.wait(lock);
                    }
                }
            }).detach();
        }
    }

    ThreadPool() = default;
    ThreadPool(ThreadPool&&) = default;

    ~ThreadPool() {
        if (static_cast<bool>(pool_)) {
            {
                std::lock_guard<std::mutex> lock(pool_->mtx);
                pool_->isClosed = true;
            }
            pool_->cond.notify_all();
        }
    }

    template <typename F>
    void addTask(F&& task) {
        {
            std::lock_guard<std::mutex> lock(pool_->mtx);
            pool_->tasks.emplace(std::forward<F>(task));
        }
        pool_->cond.notify_one();
    }
private:
    struct Pool {
        std::queue<std::function<void()>> tasks;
        std::condition_variable cond;
        std::mutex mtx;
        bool isClosed;
    };
    std::shared_ptr<Pool> pool_;
};

#endif // __THREADPOOL_H__

手搓 std::shared_ptr

class SharedCount {
public:
    SharedCount() : count_{1} {}
    void add() { ++count_; }
    void minus() { --count_; }
    int get() { return count_; }
private:
    std::atoimc<int> count_;
};

template <class T>
class SharedPtr {
public:
    SharedPtr() : ptr(nullptr), ref_count_(nullptr) {}
    SharedPtr(T* ptr) : ptr_(ptr), ref_count_(new SharedCount) {}
    ~SharedPtr() { clean(); }
    SharedPtr(const SharedPtr& p) {
        this->ptr_ = p.ptr_;
        this->ref_count_ = p.ref_count_;
        ref_count_->add();
    }
    SharedPtr(SharedPtr&& p) {
        this->ptr_ = p.ptr_;
        this->ref_count_ = p.ref_count_;
        p.ptr_ = nullptr;
        p.ref_count_ = nullptr;
    }
    SharedPtr& operator=(const SharedPtr& p) {
        if (&p == this) return *this;
        clean();
        this->ptr_ = p.ptr_;
        this->ref_count_ = p.ref_count_;
        ref_count->add();
        return *this;
    }
    SharedPtr& operator=(SharedPtr&& p) {
         if (&p == this) return *this;
        clean();
        this->ptr_ = p.ptr_;
        this->ref_count_ = p.ref_count_;
        p.ptr_ = nullptr;
        p.ref_count_ = nullptr;
        return *this;
    }
private:
    void clean() {
        if (ref_count_) {
            ref_count_->minus();
            if (ref_count_->get() == 0) {
                if (ptr_) delete ptr_;
                delete ref_count_;
            }
        }
    }
private:
    T* ptr_;
    SharedCount* ref_count_;
};