Linux_网络项目_WEB服务器 处理服务器写入失败后sigpipe信号导致服务器崩溃退出问题，引入线程池缓解大量请求，服务器组件化重构，在线计算机业务测试

1. 处理服务器写入管道出错

经过测试，服务器在读取报文时如果出错可以选择直接关闭这个TCP里链接来节省资源。这个问题好解决不在赘述

此外如果服务器使用CGI时，向管道写入数据失败时，服务器进程会收到sigpipe信号直接崩溃。所以这里选择直接忽视这个信号。

class HttpSever
{
private:
    int port;
    TcpSever *tcp_sever;
    bool states; // 标记服务器运行状态
    void InitSever()
    {
        // 信号SIGPIPE需要进行忽略，防止服务器写入管道时失败服务器崩溃
        signal(SIGPIPE, SIG_IGN);
        tcp_sever = TcpSever::GetInstance(port);
    }

public:
    HttpSever(int _port = PORT)
    {
        port = _port;
        tcp_sever = nullptr;
        states = true;
        InitSever();
    }
    ~HttpSever() {}
    void Loop()
    {
        LOG(INFO, "---http sever loop begin---");
        int listen_socket = tcp_sever->GetLinstenSocket();
        while (states != false)
        {
            struct sockaddr_in client; // 客户端信息
            socklen_t len = sizeof(client);
            int sock = accept(listen_socket, (struct sockaddr *)&client, &len);
            if (sock < 0)
            {
                // 套接字监听失败
                continue;
            }
            LOG(INFO, "get a new link");
            int *_sock = new int(sock);
            pthread_t tid = 0;
            pthread_create(&tid, nullptr, Entrance::HanderReq, _sock);
            pthread_detach(tid); // 线程分离
        }
    }
};

2. 引入线程池缓解大量请求导致服务器崩溃

设计线程任务类

#pragma once

#include <iostream>
#include "../Protocol.hpp"

// 设计线程任务队列
class Task
{
private:
    int sock;
    CallBack callback; // 设置回调
public:
    Task() {}
    Task(int _sock)
    {
        sock = _sock;
    }
    void ProcessOn()
    {
        callback(sock);
    }
};

服务器在收到链接时不创建线程，而是构建线程任务，然后将线程任务放入到线程任务队列上，最后线程池从任务队列上拿去任务处理即可，线程拿到任务后，通过任务里的CallBack回调函数执行不同的任务

线程任务CallBack设计紧贴前面重构前的代码，将Entrance类更改成CallBack即可，这里设计仿函数，线程回调函数通过()直接访问解析请求函数

// 线程工作入口
class CallBack
{
public:
    void operator()(int sock)//仿函数
    {
        HanderReq(sock);
    }
    // 处理HTTP请求
    static void HanderReq(int _sock)
    {
        LOG(INFO, "http request hander begin");
        EndPoint *endpoint = new EndPoint(_sock);
        endpoint->ReadRequest();
        if (endpoint->Stop() != true)
        {
            LOG(INFO, "recv success! build request begin");
            endpoint->BuildResponse();
            endpoint->SendResponse();
        }
        else
        {
            LOG(WARNING, "recv error! please try again");
        }
        delete endpoint;
        LOG(INFO, "http request hander end");
    }
};

单例线程池组件设计

ThreadPool

#pragma once
#include <iostream>
#include "task.hpp"
#include <queue>
#include <pthread.h>
#include "../log/log.hpp"
#define THREAD_NUM 6
// 单例模式
class ThreadPool
{
private:
    // 生产者消费者模型
    std::queue<Task> task_queue; // 临界资源
    int thread_count;            // 线程数
    bool stop;                   // 线程池是否停止
    pthread_mutex_t mutex;
    pthread_cond_t cond;
    static ThreadPool *instance;
    bool init_threadPool() // 初始化线程池
    {
        for (int i = 0; i < thread_count; i++)
        {
            pthread_t thread_id;
            if (0 != pthread_create(&thread_id, NULL, thread_routine, this))
            {
                // 创建线程失败
                LOG(FATAL, "init threadpool error!");
                return false;
            }
        }
        LOG(INFO, "http sever init threadpool success");
        return true;
    }
    static void *thread_routine(void *args) // 线程执行函数 static 删除类的this指针,对象通过线程的参数传递
    {
        ThreadPool *pool = (ThreadPool *)args;
        while (!pool->stop)
        {
            Task task;
            pthread_mutex_lock(&pool->mutex);
            while (pool->task_queue.empty()) // while 不能换成if
            {
                pool->thread_wait(); // 线程唤醒后一定占有互斥锁
            }
            task = pool->task_queue.front();
            pool->task_queue.pop();
            pthread_mutex_unlock(&pool->mutex);
            task.ProcessOn();
        }
        return NULL;
    }
    void thread_wait() // 任务队列无任务，线程休眠
    {
        pthread_cond_wait(&cond, &mutex);
    }
    void thread_wakeup() // 任务队列有任务，线程唤醒
    {
        pthread_cond_signal(&cond); // 唤醒一个线程即可
    }
    ThreadPool(int thread_num = THREAD_NUM)
    {
        thread_count = thread_num;
        stop = false;
        pthread_mutex_init(&mutex, nullptr);
        pthread_cond_init(&cond, nullptr);
        init_threadPool();
    }
    ThreadPool(const ThreadPool &) = delete;

public:
    static ThreadPool *GetInstance()
    {
        static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER; // 静态锁直接初始化，不需要释放
        if (instance == nullptr)
        {
            pthread_mutex_lock(&lock);
            if (instance == nullptr)
            {
                instance = new ThreadPool();
            }
            pthread_mutex_unlock(&lock);
        }
        return instance;
    }
    ~ThreadPool()
    {
        pthread_mutex_destroy(&mutex);
        pthread_cond_destroy(&cond);
    }
    void push_task(const Task &task)
    {
        pthread_mutex_lock(&mutex);
        task_queue.push(task);
        pthread_mutex_unlock(&mutex);
        thread_wakeup();
    }
    bool is_stop()
    {
        return stop;
    }
};

ThreadPool *ThreadPool::instance = nullptr;

HttpSever函数更换为线程池同时组件化

#pragma once
#include "./TcpSever/TcpSever.hpp"
#include "Protocol.hpp"
#include "./log/log.hpp"
#include <signal.h>
#include <pthread.h>
#include "./ThreadPool/task.hpp"
#include "./ThreadPool/threadpool.hpp"
#define PORT 8080

class HttpSever
{
private:
    int port;
    TcpSever *tcp_sever;
    bool states; // 标记服务器运行状态
    ThreadPool threadpool;
    void InitSever()
    {
        // 信号SIGPIPE需要进行忽略，防止服务器写入管道时失败服务器崩溃
        signal(SIGPIPE, SIG_IGN);
        tcp_sever = TcpSever::GetInstance(port);
    }

public:
    HttpSever(int _port = PORT)
    {
        port = _port;
        tcp_sever = nullptr;
        states = true;
        InitSever();
    }
    ~HttpSever() {}
    void Loop()
    {
        LOG(INFO, "---http sever loop begin---");
        int listen_socket = tcp_sever->GetLinstenSocket();
        while (states != false)
        {
            struct sockaddr_in client; // 客户端信息
            socklen_t len = sizeof(client);
            int sock = accept(listen_socket, (struct sockaddr *)&client, &len);
            if (sock < 0)
            {
                // 套接字监听失败
                continue;
            }
            LOG(INFO, "get a new link");
            // 构建任务
            Task task(sock);
            threadpool.push_task(task);
        }
    }
};

测试运行结果如下：线程池创建6个线程，初始化线程池正确。同时用户报文发送错误，日志级别WARING级别

3.代码位置

Github
Gitee

4. 在线计算机业务运行截图

除0错误等其他错误会导致子进程错误退出，服务器捕捉到后跳转到错误页面即404.html