从零开始编写 webserver (三) 线程池与数据库连接池

介绍

使用线程池和数据库的连接池是为了避免频繁地创建或释放资源，从而提升性能。这个项目中的线程池设计的比较简单，是创建一个任务队列，然后创建一定数量的线程，线程不断从任务队列中取出任务来执行。

数据库连接池也设计的比较简单。

线程池

先贴代码

thread.h

cpp 复制代码

#include <mutex>
#include <condition_variable>
#include <queue>
#include <functional>
#include <thread>
#include <assert.h>

class threadpool
{
public:
    threadpool(int threadcount = 8)
    {
        pool_ptr = std::make_shared<pool>();
        pool_ptr->isClose = false;
        for (int i = 0; i < threadcount; i++)
        {
            std::thread([this]()
                        {
                std::unique_lock<std::mutex> locker(pool_ptr->mtx);
                while(true)
                {
                    if(!pool_ptr->task.empty())
                    {
                        auto temp_task = std::move(pool_ptr->task.front());
                        pool_ptr->task.pop();
                        locker.unlock();
                        temp_task();
                        locker.lock();
                    }
                    else if(pool_ptr->isClose)
                    {
                        break;
                    }
                    else
                    {
                        pool_ptr->cond.wait(locker);
                    }
                } })
                .detach();
        }
    }

    ~threadpool()
    {
        std::lock_guard<std::mutex> locker(pool_ptr->mtx);
        pool_ptr->isClose = true;
        pool_ptr->cond.notify_all();
    }

    template <typename T>
    void add_task(T &&task)
    {
        std::lock_guard<std::mutex> locker(pool_ptr->mtx);
        pool_ptr->task.emplace(std::forward<T>(task));
        pool_ptr->cond.notify_one();
    }

private:
    struct pool
    {
        std::mutex mtx;
        std::condition_variable cond;
        bool isClose;
        std::queue<std::function<void()>> task;
    };
    std::shared_ptr<pool> pool_ptr;
};

add_task函数

锁住互斥量，将任务添加到任务队列，然后唤醒一个工作线程。

构造函数

首先创造一个struct pool结构体，并使用智能指针来管理生命周期，然后创建了threadcount个数个线程，每个线程首先拿到pool_ptr->mtx，在线程的循环中如果任务队列非空，就取出队首的任务并执行，从取出任务到执行完任务这段时间线程是没有拿着锁的，这个时候其他线程便可以从任务队列中取任务。如果任务队列为空，那么就等待条件变量pool_ptr->mtx。

数据库连接池

sqlconnpool.h

cpp 复制代码

#ifndef SQLCONNPOOL_H
#define SQLCONNPOOL_H

#include <queue>
#include <mutex>
#include <mysql/mysql.h>
#include <semaphore.h>
#include <assert.h>
#include <string>
#include "../log/log.h"

class sqlconnpool
{
public:
    static sqlconnpool *Instance();
    void init(const char *host, int port, const char *user, const char *pwd, const char *dbName, int connSize = 10);
    MYSQL *get_conn();
    void free_conn(MYSQL *sql_ptr);
    int get_conn_cnt();
    void close_pool();

private:
    sqlconnpool() = default;
    ~sqlconnpool() = default;

    int MAX_CONN;
    std::queue<MYSQL *> connQue;
    sem_t sem_id;
    std::mutex mtx;
};

class sqlconnRAII
{
public:
    sqlconnRAII(MYSQL **sql, sqlconnpool *sqlconn_prt)
    {
        assert(sqlconn_prt);
        *sql = sqlconn_prt->get_conn();
        sql_ = *sql;
        sqlconn_ptr_ = sqlconn_prt;
    }
    ~sqlconnRAII()
    {
        if (sql_)
            sqlconn_ptr_->free_conn(sql_);
    }

private:
    MYSQL *sql_;
    sqlconnpool *sqlconn_ptr_;
};

#endif

sqlconnpool.cpp

cpp 复制代码

#include "sqlconnpool.h"

sqlconnpool *sqlconnpool::Instance()
{
    static sqlconnpool sql_conn;
    return &sql_conn;
}

void sqlconnpool::init(const char *host, int port, const char *user, const char *pwd, const char *dbName, int connSize)
{
    assert(connSize > 0);
    for (int i = 0; i < connSize; i++)
    {
        MYSQL *conn = nullptr;
        conn = mysql_init(conn);
        if (!conn)
        {
            LOG_ERROR("Mysql init error!");
            assert(conn);
        }
        conn = mysql_real_connect(conn, host, user, pwd, dbName, port, nullptr, 0);
        if (!conn)
        {
            // printf("Mysql connect error!, host:%s, user:%s, pwd:%s, dbName:%s, port:%d\n", host, user, pwd, dbName, port);
            LOG_ERROR("Mysql connect error!");
            assert(conn);
        }
        connQue.emplace(conn);
    }
    MAX_CONN = connSize;
    sem_init(&sem_id, 0, connSize);
}

MYSQL *sqlconnpool::get_conn()
{
    std::lock_guard<std::mutex> locker(mtx);
    if (connQue.empty())
    {
        LOG_WARN("SqlConnPool busy!");
        return nullptr;
    }
    sem_wait(&sem_id);
    MYSQL *sql_ptr = connQue.front();
    connQue.pop();
    return sql_ptr;
}

void sqlconnpool::free_conn(MYSQL *sql_ptr)
{
    std::lock_guard<std::mutex> locker(mtx);
    sem_post(&sem_id);
    connQue.emplace(sql_ptr);
}

int sqlconnpool::get_conn_cnt()
{
    std::lock_guard<std::mutex> locker(mtx);
    return connQue.size();
}

void sqlconnpool::close_pool()
{
    std::lock_guard<std::mutex> locker(mtx);
    while (connQue.size())
    {
        MYSQL *sql_ptr = connQue.front();
        connQue.pop();
        mysql_close(sql_ptr);
    }
    mysql_library_end();
}

数据库连接池使用了两个类，sqlconnpool类作用是创建具体的数据库连接，sqlconnpool类使用了C++11局部变量的多线程安全来实现单例，提前创建一定数量的数据库连接并放入队列中，sqlconnRAII类用于实现数据库连接的RAII（R esource A cquisition I s I nitialization，资源获取即初始化，详情可以看这篇文章(3 封私信 / 24 条消息) c++经验之谈一：RAII原理介绍 - 知乎）

在需要使用数据库连接的时候，调用sqlconnRAII的构造函数，并且讲数据库连接的地址和sqlconnpool类传递进去，就可以获取到一个数据库连接，这个数据库连接的生命周期就是sqlconnRAII类的生命周期，sqlconnRAII类的生命周期结束之后会将数据库连接自动放回队列中。