Webserver(1): C++实现线程池

已于 2024-03-03 11:48:40 修改
阅读量986 收藏 21
点赞数 16
文章标签： c++
于 2024-03-03 11:45:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45586192/article/details/136426868
版权

在实现线程池之前，首先对线程池中所需要用到的互斥锁、条件变量和信号量进行了简单的封装。

互斥锁、条件变量和信号量封装

locker.h头文件如下（已详细注释）

/*
这里面对互斥锁，条件变量和信号量进行了封装
保证工作队列的线程同步与数据安全
*/

#ifndef LOCKER_H
#define LOCKER_H
/*
这是一个简单的C或C++头文件保护（header guard）机制，用于防止头文件被多次包含（include）。
#ifndef LOCKER_H：#ifndef是预处理指令，用于检查LOCKER_H这个宏是否已经定义。如果LOCKER_H没有被定义，那么后面的代码（直到#endif）会被编译器包含（include）。
#define LOCKER_H：这行代码定义了一个宏LOCKER_H。一旦这个宏被定义，再次遇到#ifndef LOCKER_H时，由于LOCKER_H已经被定义，所以其后的代码不会被再次包含。
#endif：这是结束#ifndef预处理的指令。
这种机制确保了在同一个编译单元中，头文件只被包含一次，避免了由于多次包含同一个头文件而可能导致的各种问题，如重复定义、多重继承等。
*/

#include <pthread.h>
#include <exception>   //异常处理
#include <semaphore.h> //信号量
#include <stdexcept>   //std::runtime_error 是定义在 <stdexcept> 头文件中的一个异常类


//可以使用互斥量（mutex 是 mutual exclusion的缩写）来确保同时仅有一个线程可以访问某项共享资源。
//任何时候，至多只有一个线程可以锁定该互斥量。试图对已经锁定的某一互斥量再次加锁，将可能阻塞线程或者报错失败
//一旦线程锁定互斥量，随即成为该互斥量的所有者，只有所有者才能给互斥量解锁。
/*
 初始化互斥量后，你可以使用 pthread_mutex_lock 函数来锁定互斥量，使用 pthread_mutex_unlock 函数来解锁互斥量。
 锁定互斥量的线程将独占对共享资源的访问，直到它解锁该互斥量。其他尝试锁定该互斥量的线程将被阻塞，直到互斥量被解锁。
 * */
//1.互斥锁类，应该确保一个线程在访问资源的时候，另外的线程不能同时访问这些资源
class Locker{
public:
    //1.1 构造函数，对互斥量进行初始话
    Locker()
    {
        //这段代码确实是在检查互斥量是否被成功初始化，并在初始化失败时抛出异常。成功初始化返回0
        if(pthread_mutex_init(&m_mutux, NULL) != 0)
        {
            throw std::runtime_error("Failed to initialize mutex");
        }

    }

    //1.2 析构函数，对互斥量进行消耗
    ~Locker()
    {
        pthread_mutex_destroy(&m_mutux);
    }

    //1.3 上锁函数
    bool lock()
    {
        return pthread_mutex_lock(&m_mutux) == 0;  //上锁成功返回0
    }

    //1.4 解锁函数
    bool unlock()
    {
    return pthread_mutex_unlock(&m_mutux) == 0;
    }

    //1.5 get函数获取互斥量
    pthread_mutex_t * get()
    {
        return &m_mutux;
    }
    /*
     * 在C++中，pthread_mutex_t 是一个结构体类型，通常用于POSIX线程编程中的互斥量。
     * 当你通过函数返回一个 pthread_mutex_t 类型的值时，你实际上是在返回这个结构体的一个副本。
     * 然而，对于互斥量这样的类型，返回其副本通常是没有意义的，因为互斥量的状态（如锁定或未锁定）不能通过简单地复制结构体来传递。
     因此，当你想从一个函数返回一个互斥量以便在其他地方使用时，通常会返回指向互斥量的指针。
     这样，调用者可以通过这个指针来操作原始的互斥量对象，而不是它的一个副本。
     * */
private:
    pthread_mutex_t m_mutux;  //互斥量
};


//2. 条件变量类
/*
 条件变量（Condition Variables）是线程同步的一种机制，它允许一个或多个线程等待某个条件成立，
 或者在某个条件成立后唤醒一个或多个等待的线程。条件变量通常与互斥锁（Mutex）一起使用，以避免竞争条件和保证线程安全。
 条件变量的类型 pthread_cond_t
    int pthread_cond_init(pthread_cond_t *restrict cond, const pthread_condattr_t *restrict attr);
    int pthread_cond_destroy(pthread_cond_t *cond);
    int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex);
    等待，调用了该函数，线程会阻塞。当这个函数调用阻塞等待的时候，会对互斥锁进行解锁，否则生产者拿不到互斥锁。解除阻塞时，重新加锁

    int pthread_cond_timedwait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex, const struct timespec *restrict abstime);
        - 等待多长时间，调用了这个函数，线程会阻塞，直到指定的时间结束。
    int pthread_cond_signal(pthread_cond_t *cond);
        - 唤醒一个或者多个等待的线程
    int pthread_cond_broadcast(pthread_cond_t *cond);
        - 唤醒所有的等待的线程
 */

/*
 条件变量（Condition Variable）是操作系统提供的一种线程间同步机制，用于在多线程环境中实现线程的等待和唤醒操作。
 它通常与互斥锁（Mutex）结合使用，用于实现复杂的线程同步。

条件变量的原理如下：

线程在进入临界区前先获取互斥锁。当某个条件不满足时，线程调用条件变量的等待（wait）函数，
并释放之前获取到的互斥锁，然后进入阻塞状态等待被唤醒。当其他线程满足了该条件时，调用条件变量的通知或广播（broadcast）函数来唤醒一个或多个等待中的线程。
 被唤醒的线程重新获得互斥锁，并检查条件是否满足。如果满足，则继续执行；如果不满足，则再次进入等待状态。

条件变量的作用是用于多线程之间关于共享数据状态变化的通信。当一个动作需要另外一个动作完成时才能进行，
即：当一个线程的行为依赖于另外一个线程对共享数据状态的改变时，这时候就可以使用条件变量。

操作系统是主动调用者，而条件变量其实是操作系统预留出的接口。
因而这里主要是去考虑记录谁在等待、记录谁要唤醒、如何唤醒的问题。条件变量是一种等待机制，每一个条件变量对应一个等待原因与等待队列。
 * */
class Cond{
public:
    //2.1 构造函数，初始化
    Cond()
    {
        if(pthread_cond_init(&m_cond, NULL) != 0)
        {
            throw std::runtime_error("Failed to initialize Condition Variables");
        }
    }

    //2.2 析构函数
    ~Cond()
    {
        pthread_cond_destroy(&m_cond);
    }

    //2.3 条件变量要配合互斥锁使用，因此需要传递一个互斥锁指针类型
    bool wait(pthread_mutex_t * mutex)
    {
        return pthread_cond_wait(&m_cond, mutex) == 0;
    }

    //2.4 timewait，还要传递一个时间t
    bool timewait(pthread_mutex_t * mutex, struct timespec t)
    {
        return pthread_cond_timedwait(&m_cond, mutex, &t) == 0;
    }

    //2.5 唤醒一个或者多个等待的线程
    bool signal()
    {
        return pthread_cond_signal(&m_cond) == 0;
    }

    //2.6 唤醒所有的等待的线程
    bool broadcast()
    {
        return pthread_cond_broadcast(&m_cond) == 0;
    }

private:
    pthread_cond_t m_cond;
};


//3. 信号量类
/*
 信号量（Semaphore）是一种用于控制多个线程或进程对共享资源访问的同步机制。
它可以看作是一个计数器，用于表示可用资源的数量。信号量的主要操作包括P操作（等待）和V操作（释放）。

P操作（Wait）：当一个线程或进程需要访问共享资源时，它首先会执行P操作。这个操作会将信号量的值减1，
表示一个资源被占用。如果信号量的值大于0，表示还有可用资源，
线程或进程可以继续执行；如果信号量的值为0，表示没有可用资源，线程或进程将被阻塞，直到有资源可用。

V操作（Signal）：当一个线程或进程完成对共享资源的访问后，它会执行V操作。这个操作会将信号量的值加1，
表示一个资源被释放。如果有其他线程或进程正在等待该资源（即被P操作阻塞），那么它们将被唤醒并继续执行。

信号量的类型 sem_t
    int sem_init(sem_t *sem, int pshared, unsigned int value);
        - 初始化信号量
        - 参数：
            - sem : 信号量变量的地址
            - pshared : 0 用在线程间 ，非0 用在进程间
            - value : 信号量中的值，生产+1，消费-1

    int sem_destroy(sem_t *sem);
        - 释放资源

    int sem_wait(sem_t *sem);
        - 对信号量加锁，调用一次对信号量的值-1，如果值为0，就阻塞，直到大于0（post）

    int sem_trywait(sem_t *sem);

    int sem_timedwait(sem_t *sem, const struct timespec *abs_timeout);
    int sem_post(sem_t *sem);
        - 对信号量解锁，调用一次对信号量的值+1

    int sem_getvalue(sem_t *sem, int *sval);


    信号量的工作原理基于两种基本操作：P（等待）操作和V（发送信号）操作。
    P操作用于获取信号量，即减少信号量值。如果信号量值大于0，表示资源可用，进程或线程可以访问该资源，并将信号量值减1；
    如果信号量值等于0，表示资源已被占用，
    进程或线程需要等待其他进程或线程释放资源，并将自己挂起，直到信号量值变为正数。
    V操作用于释放信号量，即增加信号量值。如果有进程或线程正在等待该信号量，则唤醒其中一个进程或线程，使其继续执行。
*/
class Sem{
public:
    Sem()
    {
        if(sem_init(&m_sem, 0, 0) != 0)
        {
            throw std::runtime_error("Failed to initialize Semaphore");
        }
    }

    ~Sem()
    {
        sem_destroy(&m_sem);
    }

    // int sem_wait(sem_t *sem); - 调用一次对信号量的值-1，如果值为0，就阻塞，直到大于0（post）
    bool wait()
    {
        return sem_wait(&m_sem) == 0;
    }

    // int sem_post(sem_t *sem); - 调用一次对信号量的值+1
    bool post()
    {
        return sem_post(&m_sem) == 0;
    }

private:
    sem_t m_sem;  //信号量
};


#endif //LOCKER_H

2.线程池

线程池是一种用于管理和重用线程的并发编程技术。在软件开发中，线程池被用来处理大量的并发任务，以提高系统性能和资源利用率。

主要的组成部分包括：

  1. 线程池管理器（Thread Pool Manager）：负责创建、销毁和管理线程池中的线程。它通常提供了添加任务、删除任务、调整线程池大小等接口，用于管理线程池的状态。

  2. 工作队列（Work Queue）：用于存储需要执行的任务。当有任务需要执行时，线程从工作队列中获取任务并执行。工作队列可以是有限大小的队列，用于控制系统资源的使用。

  3. 线程池（Thread Pool）：包含一组预先创建的线程，这些线程可以重复使用来执行任务。通过维护一组可重用的线程，线程池可以减少线程的创建和销毁开销，提高系统的性能和响应速度。

  4. 任务（Task）：需要在线程池中执行的工作单元。任务可以是任意类型的计算、I/O 操作或其他类型的工作。

线程池的工作流程通常如下：

  • 初始时，线程池会创建一定数量的线程，并将它们置于等待状态。
  • 当有任务需要执行时，任务被添加到工作队列中。
  • 线程池中的线程会不断地从工作队列中获取任务，并执行这些任务。
  • 执行完任务后，线程会再次回到等待状态，等待下一个任务的到来。
  • 当线程池不再需要时，可以销毁线程池中的线程，释放资源。

线程池的优势在于：

  • 降低线程创建和销毁的开销。通过重用线程，减少了频繁创建和销毁线程的性能开销。
  • 控制并发线程数量。线程池可以限制同时执行的线程数量，防止系统资源被过度占用。
  • 提高系统响应速度。通过并发执行多个任务，可以提高系统的并发处理能力和响应速度。

在C++中，this 是一个特殊的指针，它指向调用成员函数的对象。当你在一个类的非静态成员函数中使用 this 时，它实际上指向调用该函数的实例。

this 指针允许你访问对象的所有成员，包括私有（private）和保护（protected）成员。

以下是 this 指针的一些关键点：

  1. 隐含传递：当你调用一个类的非静态成员函数时，this 指针会自动作为第一个参数传递给该函数。虽然你不需要显式地传递它，但在函数内部，你可以使用 this 来引用调用该函数的对象。

  2. 类型：this 指针的类型是指向类类型的指针。例如，如果你有一个名为 MyClass 的类，那么 this 的类型就是 MyClass*。

  3. 使用场景：this 指针通常用于以下情况：

    • 当成员函数的参数名和类的成员变量名相同时，为了避免歧义，可以使用 this 指针来明确指代类的成员变量。
    • 当你想在成员函数中返回对象本身（通常用于链式操作）时，可以使用 return *this;。
    • 在某些情况下，你可能想将 this 指针传递给其他函数或方法。 
      class MyClass {  
public:  
    int value;  
  
    MyClass(int val) : value(val) {}  
  
    // 使用 this 指针来访问和修改成员变量  
    void setValue(int newVal) {  
        this->value = newVal; // this-> 是可选的，但在某些情况下可以帮助提高代码的可读性  
    }  
  
    // 返回对象本身，以便进行链式操作  
    MyClass* incrementValue() {  
        this->value++;  
        return this;  
    }  
};  
  
int main() {  
    MyClass obj(10);  
    obj.setValue(20);  
    obj.incrementValue()->incrementValue(); // 链式操作  
    return 0;  
}

线程池代码threadpool.h

//线程池的实现
#ifndef THREADPOOL_H
#define THREADPOOL_H

#include <pthread.h>
#include <list>
#include "locker.h"
#include <exception>
#include <cstdio>
#include <stdexcept>
#include <iostream>
using namespace std;


//定义成模板类，是为了代码的复用，
//任务可能是不同的，T就是任务类
template<typename T>
class Threadpool{
public:
    //1 构造函数，初始化线程数量, 请求队列中最多允许的，等待处理的请求数量
    Threadpool(int thread_number = 8, int max_requests = 10000);

    //2 析构函数
    ~Threadpool();

    //3 向工作队列中去添加任务，append方法，类型为T
    bool append(T * request);

private:
    //静态函数，不能访问非静态的成员变量，线程所要执行实现的功能
    static void* worker(void* arg);
    /*
     *
     * */

    void run();

private:
    //1 线程的数量
    int m_thread_number;

    //2 线程池数组，存储创建线程的pid，大小与线程数量一致
    pthread_t * m_threads;

    //3 工作队列中最多允许的，等待处理的请求数量
    int m_max_requests;

    //4 工作队列
    std::list<T*> m_workqueue;
    /*
     * 内存管理：使用指针允许你更灵活地管理内存。例如，如果你有一个大型对象或动态分配的对象，
     * 将其存储在std::list<T>中可能会导致不必要的内存复制，因为std::list在插入和删除元素时可能需要重新分配内存。
     * 使用指针可以避免这种复制，因为实际上你只是在复制指针（一个小的内存地址），而不是整个对象。
     * */

    //5 互斥锁
    Locker m_queue_mutex;

    //6 信号量用来判断是否有任务需要处理
    Sem m_queue_sem;

    //7 是否结束线程
    bool m_stop;
};

//1 构造函数的类外初始化，在这个里面要创建出来线程
template<typename T>
Threadpool<T>::Threadpool(int thread_number, int max_requests) : m_thread_number(thread_number), m_max_requests(max_requests),
m_stop(false), m_threads(nullptr)
{
    //1. 参数是否正确的判断
    if(thread_number <= 0 || max_requests <= 0)
    {
        throw std::runtime_error("Failed to initialize Threadpool");
    }

    //2. 根据线程的数量创建出线程池数组，存储创建线程的pid,析构的时候需要销毁
    m_threads = new pthread_t[thread_number];
    if(!m_threads)
    {
        throw std::runtime_error("m_threads Error");
    }

    //3. 创建thread_number，线程pid存储在m_threads中，并设置为线程分离
    for(int i = 0; i < thread_number; i++)
    {
        cout<<"create" << i << " th thread"<<endl;
        //线程执行的代码在worker中，是个静态函数,创建的时候，并没有显示指定存储子线程的tid的变量，而是直接放在数组中
        if(pthread_create(m_threads + i, NULL, worker, this) != 0)
        {
            //子线程创建失败，删掉这个数组m_threads
            delete[] m_threads;
            /*
             * 在C++中，delete 和 delete[] 是用于释放动态分配的内存的运算符，但它们的使用场景有所不同。
             * delete：用于释放通过 new 运算符单个分配的对象。
               delete[]：用于释放通过 new[] 运算符分配的对象数组。
             * */
            throw std::runtime_error("pthread_create Error");
        }

        //设置线程分离
        if(pthread_detach(m_threads[i]) != 0)
        {
            delete[] m_threads;
            throw std::runtime_error("pthread_detach Error");
        }
    }
}

//2 析构函数
template<typename T>
Threadpool<T>::~Threadpool()
{
    delete[] m_threads;
    m_stop = true;
}


//3 向工作队列中去添加任务，append方法，类型为T,并且需要确保线程同步
template<typename T>
bool Threadpool<T>::append(T *request)
{
    //1 上锁
    m_queue_mutex.lock();

    //2 如果工作队列中的大小大于最大的工作队列中最多允许的，等待处理的请求数量，解锁，返回错误，处理不了了
    if(m_workqueue.size() > m_max_requests)
    {
        m_queue_mutex.unlock();
        return false;
    }

    //3 向工作队列中添加
    m_workqueue.push_back(request);
    m_queue_mutex.unlock(); //解锁
    m_queue_sem.post(); //信号量增加，说明工作队列中有了新任务
}


//4 线程执行的代码在worker中，是个静态函数
/*
静态函数，它不能访问非静态的成员函数
if (pthread_create(m_threads + i, NULL, worker, NULL) != 0);
在创建线程的时候
if (pthread_create(m_threads + i, NULL, worker,this) != 0); this代表本类对象，是Threadpool类型对象
 * */
template<typename T>
void* Threadpool<T>::worker(void * arg)
{
    Threadpool * pool = (Threadpool *) arg;
    pool->run();
    return pool;
}


//运行函数run，在工作队列中去任务，做任务
template<typename T>
void Threadpool<T>::run()
{
    while(!m_stop)
    {
        //工作队列中的信号量-1，如果为0则阻塞在这
        m_queue_sem.wait();

        //加锁
        m_queue_mutex.lock();

        //如果工作队列为空就解锁
        if(m_workqueue.empty())
        {
            m_queue_mutex.unlock();
            continue;
        }

        //取第一个任务
        T* request = m_workqueue.front();
        m_workqueue.pop_front();
        m_queue_mutex.unlock();

        if(!request)
        {
            continue;
        }

        request->process(); //调用process函数执行任务
    }

}




#endif //THREADPOOL_H

/*
 * C++中的静态函数
 * 在C++中，静态成员函数（Static Member Functions）是类的一部分，但它们与类的实例（对象）无关。
 * 与类关联，而非对象关联：静态成员函数属于类本身，而不是类的某个特定对象。因此，它们可以在没有创建类对象的情况下被调用。
 * 访问限制：静态成员函数只能直接访问静态成员变量和其他静态成员函数，不能访问类的非静态成员变量和非静态成员函数，除非通过类的实例或指针/引用。
 * 不隐藏this指针：静态成员函数不接收this指针，因此它们不能访问类的非静态成员，因为这些成员需要通过this指针来访问。
 * 调用方式：可以通过类名和作用域解析运算符::来调用静态成员函数，也可以通过类的对象来调用（尽管这样做并不常见）。
静态成员函数不能直接访问类的非静态成员变量，因为静态成员函数不与类的任何特定实例关联，而非静态成员变量是与类的实例关联的。
 但是，有一些方法可以间接地访问非静态成员变量：

通过参数传递：你可以将非静态成员变量的引用或指针作为参数传递给静态成员函数。
这样，静态成员函数就可以通过这个参数来访问和修改非静态成员变量。

通过类的实例：如果静态成员函数能够获得类的某个实例的引用或指针，那么它可以通过这个实例来访问非静态成员变量。
这通常是通过将实例作为参数传递给静态成员函数来实现的。



 * */

傲慢与偏见L
关注
C++实现基于线程池的HTTP服务器
笔者从事电信媒体开发多年，愿意将多年的开发经验分享给同行
12-18 1262
随着互联网的飞速发展，HTTP服务器作为Web应用的基础设施，其性能与并发处理能力显得尤为重要。C++作为一门高效、底层的编程语言，结合多线程技术和线程池模型，可以实现高性能的HTTP服务器。本文将详细介绍如何使用C++实现一个基于线程池的HTTP服务器，优化资源利用和响应时间。
Webserver：用C ++编写的WebServer
02-03
【标题】：“Webserver：用C++编写的WebServer” 在IT行业中，Web服务器是互联网基础设施的核心组件之一，它们负责处理HTTP（超文本传输协议）请求，并返回相应的网页内容。本项目聚焦于一个使用C++语言编写的Web...
WebServer：C ++高性能Web服务器
02-03
WebServer：C ++高性能Web服务器
linux C++ webserver
01-31
linux C++实现的webserver 包含tcpserver和tcpclient，线程池，select模式， epoll的LT和ET模式
Webserver学习笔记——基础知识&线程池
最新发布
I_WANNA_AC的博客
08-27 769
webserver项目中 线程池 的学习笔记
C++——WebServer服务器项目
摸鱼中......
04-18 3万+
项目场景： C++——WebServer服务器编程 项目搭建 （1）配置虚拟机，下载XShell、Xftp以及windows版本的VScode； （2）安装SSH： sudo apt install openssh-server （3）在XShell中配置会话以连接到虚拟机，VScode中配置远程SSH； （4）安装数据库： sudo apt install mysql-server sudo apt install mysql-client sudo apt install libmysqlclien
【webserver】 C++ webserver项目 概念部分
m0_51319352的博客
03-21 2263
webserver项目基础概念
〖Linux〗使用gsoap搭建web server（C++）
weixin_33888907的博客
11-01 100
1. gsoap的好处就不用说了：百度百科 2. gsoap的下载地址：项目地址，目前我使用的是2.8.15版本 3. 开发环境：Ubuntu13.10 4. 具体操作步骤（以简单相加为例）： 　　1）编写add.h（头文件） //gsoap ns service name: calc //gsoap ns service protocol: SOAP //gsoap ns se...
简单web服务器的实现（C++）
热门推荐
qq_36573828的博客
09-20 8万+
一、具体功能实现 GET方法请求解析 POST方法请求解析 返回请求资源页面 利用GET方法实现加减法 利用POST方法实现加减法 HTTP请求行具体解析 400、403、404错误码返回的处理 注意：！！本人也是小白一只，这是刚刚开始学习网络编程写的东西，存在很多问题。也未用到RAII等机制，纯属是披着C++皮的C语言项目，类的封装也不是太好。也未经过压力、性能等测试。 二、什么...
C++实现高并发webserver项目
06-02
在本项目"C++实现高并发webserver项目"中，我们将探讨如何使用C++构建一个能够处理高并发请求的Web服务器。这个服务器不仅包含了基础的HTTP服务功能，还涉及到了线程池、数据库连接池以及状态机转换等高级技术，使得...
HttpServer.rar_C++ web服务器_HTTPServer_c++ webserver_c++ webserv
07-13
【标题】"HttpServer.rar_C++ web服务器_HTTPServer_c++ webserver_c++ webserv" 涉及的核心知识点是C++实现的Web服务器，通常称为HTTPServer。在Web开发中，服务器端扮演着至关重要的角色，它们负责接收客户端（如...
使用C++编程的webserver，里面附详细的代码备注
07-20
1.使用epoll技术实现I/O复用，支持多客户端连接； 2.使用线程池机制+同步I/O模拟Proactor事件处理模式，提升响应效率； 3.使用主从状态机作为逻辑单元解析HTTP请求报文； 4.使用定时器链表检测非活跃连接； 5.使用Webbench压力测试，可实现上万的并发连接数据交换； 代码基本上关键部分都加上了备注，源代码是参考的https://www.nowcoder.com/courses上面的课程教学，建议直接看游双老师的书籍《Linux高性能服务器编程》
WebServer c++ linux
04-11
一个在linux下用C++写的简单的web服务器源代码，只有一个文件，按照文件里的说明进行编译后，可以在浏览器端访问html页面（可以显示图片），如果需要扩充功能，可自行修改
Web服务器C++实现
02-25
Web服务器C++实现, Web server, webserver实现，
WebServer:C ++高性能HTTP Web服务器
05-17
A C++ Lightweight Web Server 简介 这是一个轻量级的 Web 服务器，目前支持 GET、HEAD 方法处理静态资源。并发模型选择: 线程池+Reactor+非阻塞方式运行。 测试页面: Part Ⅰ Part Ⅱ 开发部署环境 操作系统: Ubuntu 5.4.0-6 Ubuntu16.04.9 编译器: g++ version 5.4.0 20160609 版本控制: git 编辑器: Vim 压测工具： Usage cmake . && make ./webserver [-p port] [-t thread_numbers] [-r website_root_path] [-d daemon_run] 核心功能及技术 状态机解析 HTTP 请求，目前支持 HTTP GET、HEAD 方法 使用 priority 队列实现的最小堆结构管理定时器，使用标记
WebServer：Web服务器的C ++实现
03-04
网络服务器 Web服务器的C ++实现
c++ webserver/第四章 网络编程基础知识
公仔面
02-28 1863
这里写目录标题1.C/S结构1.优点2.缺点2. B/S结构2.优点3.缺点3. MAC地址1.网络设配器(网卡,网络接口器)2. MAC地址（Media Access Control Address）4. IP地址1.定义2.特殊地址3.类型4.子网掩码1.作用:2.计算方法5.端口1.定义2.作用:3.数量4.特殊端口1.普遍使用的周知端口2.注册端口（Registered Ports）3.动态端口 / 私有端口（Dynamic Ports / Private Ports）3.动态端口 / 私有端口（D
学到就是赚到，面试加分项之WebServer线程池管理！
兰陵笑笑生
08-16 397
大家好，这篇文章我们来讨论一个话题，怎么去管理 SpringBoot 内置的三大 WebServer（Tomcat、Jetty、Undertow）的线程池，包括监控告警、动态调参。 不管是应对越来越卷的面试考察，还是自己项目日常性能调优，绝对有用，学到就是赚到，搬好椅子，开始我们的分析之旅。 写在前面 要想去管理第三方组件的线程池，首先肯定要对这些组件有一定的熟悉度，了解整个请求的一个处理过程，找到对应处理请求的线程池，这些线程池不一定是 JUC 包下的 ThreadPoolExecutor 类，也可能是
基于C++实现的简易WEB服务器
毕业作品网站
05-23 2206
函数对读时间进行处理，传入的参数为epoll监听到写事件的文件描述符对应的HttpConn，函数具体如下，程序将读的工作（OnRead_工作函数）添加到线程池中的工作队列中，交给线程池中的线程去处理。OnRead_工作函数如下，程序调用对应客户端连接的read函数，将客户端连接的套接字中读数据到改客户端连接的对应的readBuff_中。函数循环调用epoll来监听连接事件，写事件和读事件，并对这些事件进行相应的处理，对于监听到的异常事件，服务器关闭相关的客户端连接。但监听到连接事件的时候，程序调用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值