WEB服务器代码解析-线程池

最新推荐文章于 2023-11-15 16:47:13 发布
最新推荐文章于 2023-11-15 16:47:13 发布
阅读量224 收藏
点赞数
分类专栏： WEB服务器开发笔记 文章标签： 服务器 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43108252/article/details/121843929
版权

locker.h

头文件

#ifndef LOCKER_H
#define LOCKER_H

#include <exception>
#include <pthread.h>
#include <semaphore.h>

// 线程同步机制封装类

#endif

定义互斥锁类

// 互斥锁类
class locker {
public:
    locker() {//构造函数
        if(pthread_mutex_init(&m_mutex, NULL) != 0) {
            throw std::exception();//抛出异常
        }//初始化互斥锁
    }

    ~locker() {//析构函数
        pthread_mutex_destroy(&m_mutex);
    }//销毁互斥锁

    bool lock() {
        return pthread_mutex_lock(&m_mutex) == 0;
    }//上锁

    bool unlock() {
        return pthread_mutex_unlock(&m_mutex) == 0;
    }//解锁

    pthread_mutex_t *get()
    {
        return &m_mutex;
    }//获得该锁；

private:
    pthread_mutex_t m_mutex;//定义互斥量；
};

封装条件变量类；

class cond {
public:
    cond(){
        if (pthread_cond_init(&m_cond, NULL) != 0) {
            throw std::exception();
        }
    }//构造函数，初始化m_cond;
    ~cond() {
        pthread_cond_destroy(&m_cond);
    }
    //析构函数，销毁信号量

    bool wait(pthread_mutex_t *m_mutex) {
        int ret = 0;
        ret = pthread_cond_wait(&m_cond, m_mutex);
        return ret == 0;
    }
    //条件变量wait，需要条件变量以及互斥锁；
    bool timewait(pthread_mutex_t *m_mutex, struct timespec t) {
        int ret = 0;
        ret = pthread_cond_timedwait(&m_cond, m_mutex, &t);
        return ret == 0;
    }
    //超时时间
    bool signal() {
        return pthread_cond_signal(&m_cond) == 0;
    }
    bool broadcast() {
        return pthread_cond_broadcast(&m_cond) == 0;
    }

private:
    pthread_cond_t m_cond;
};

封装信号量类；

// 信号量类
class sem {
public:
    sem() {
        if( sem_init( &m_sem, 0, 0 ) != 0 ) {
            throw std::exception();
        }
    }//构造函数创建，初始化信号量
    sem(int num) {
        if( sem_init( &m_sem, 0, num ) != 0 ) {
            throw std::exception();
        }
    }//构造的时候将初始化的值传递进来，两个构造函数；
    ~sem() {
        sem_destroy( &m_sem );
    }
    // 等待信号量
    bool wait() {
        return sem_wait( &m_sem ) == 0;
    }
    // 增加信号量
    bool post() {
        return sem_post( &m_sem ) == 0;
    }
private:
    sem_t m_sem;
};

整体代码：

#ifndef LOCKER_H
#define LOCKER_H

#include <exception>
#include <pthread.h>
#include <semaphore.h>

// 线程同步机制封装类

// 互斥锁类
class locker {
public:
    locker() {//构造函数
        if(pthread_mutex_init(&m_mutex, NULL) != 0) {
            throw std::exception();//抛出异常
        }//初始化互斥锁
    }

    ~locker() {//析构函数
        pthread_mutex_destroy(&m_mutex);
    }//销毁互斥锁

    bool lock() {
        return pthread_mutex_lock(&m_mutex) == 0;
    }//上锁

    bool unlock() {
        return pthread_mutex_unlock(&m_mutex) == 0;
    }//解锁

    pthread_mutex_t *get()
    {
        return &m_mutex;
    }//获得该锁；

private:
    pthread_mutex_t m_mutex;
};


// 条件变量类
class cond {
public:
    cond(){
        if (pthread_cond_init(&m_cond, NULL) != 0) {
            throw std::exception();
        }
    }//构造函数，初始化m_cond;
    ~cond() {
        pthread_cond_destroy(&m_cond);
    }
    //析构函数，销毁信号量

    bool wait(pthread_mutex_t *m_mutex) {
        int ret = 0;
        ret = pthread_cond_wait(&m_cond, m_mutex);
        return ret == 0;
    }
    //条件变量wait，需要条件变量以及互斥锁；
    bool timewait(pthread_mutex_t *m_mutex, struct timespec t) {
        int ret = 0;
        ret = pthread_cond_timedwait(&m_cond, m_mutex, &t);
        return ret == 0;
    }
    //超时时间
    bool signal() {
        return pthread_cond_signal(&m_cond) == 0;
    }
    bool broadcast() {
        return pthread_cond_broadcast(&m_cond) == 0;
    }

private:
    pthread_cond_t m_cond;
};


// 信号量类
class sem {
public:
    sem() {
        if( sem_init( &m_sem, 0, 0 ) != 0 ) {
            throw std::exception();
        }
    }//构造函数创建，初始化信号量
    sem(int num) {
        if( sem_init( &m_sem, 0, num ) != 0 ) {
            throw std::exception();
        }
    }//构造的时候将初始化的值传递进来，两个构造函数；
    ~sem() {
        sem_destroy( &m_sem );
    }
    // 等待信号量
    bool wait() {
        return sem_wait( &m_sem ) == 0;
    }
    // 增加信号量
    bool post() {
        return sem_post( &m_sem ) == 0;
    }
private:
    sem_t m_sem;
};

#endif

线程池类

threadpool.h

线程池类，将其定义成模版类，可以应用于代码的复用；T代表任务类；

template<typename T>
class threadpool
{
public:

private:
}

在private中定义各种变量

  // 线程的数量
    int m_thread_number;  
    
    // 描述线程池的数组，大小为m_thread_number    
    pthread_t * m_threads;

    // 请求队列中最多允许的、等待处理的请求的数量  
    int m_max_requests; 
    
    // 请求队列
    std::list< T* > m_workqueue;  

    // 保护请求队列的互斥锁
    locker m_queuelocker;   //locker.h中定义过

    // 是否有任务需要处理
    sem m_queuestat;  //locker.h中定义过

    // 是否结束线程          
    bool m_stop;

public中所有的函数；

  /*thread_number是线程池中线程的数量，max_requests是请求队列中最多允许的、等待处理的请求的数量*/
    threadpool(int thread_number = 8, int max_requests = 10000);//构造函数
    ~threadpool();
    bool append(T* request);//添加任务；

构造函数：

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(NULL) {

    if((thread_number <= 0) || (max_requests <= 0) ) {
        throw std::exception();
    }

    m_threads = new pthread_t[m_thread_number];
    if(!m_threads) {
        throw std::exception();
    }

    // 创建thread_number 个线程，并将他们设置为脱离线程。
    for ( int i = 0; i < thread_number; ++i ) {
        printf( "create the %dth thread\n", i);
        if(pthread_create(m_threads + i, NULL, worker, this ) != 0) {
            delete [] m_threads;
            throw std::exception();
        }
          //为了在线程使用之后自己释放资源
        
        if( pthread_detach( m_threads[i] ) ) {
            delete [] m_threads;
            throw std::exception();
        }//线程脱离失败，释放线程数组
    }
}

析构函数

template< typename T >
threadpool< T >::~threadpool() {
    delete [] m_threads;
    m_stop = true;
}

往队列中添加任务：

template< typename T >
bool threadpool< T >::append( T* request )
{
    // 操作工作队列时一定要加锁，因为它被所有线程共享。
    m_queuelocker.lock();
    if ( m_workqueue.size() > m_max_requests ) {
        m_queuelocker.unlock();
        return false;
    }
    m_workqueue.push_back(request);
    m_queuelocker.unlock();
    m_queuestat.post();//增加信号量，通过信号量来判断线程是阻塞还是可以立即开始；
    return true;
}

private:
    /*工作线程运行的函数，它不断从工作队列中取出任务并执行之*/
    static void* worker(void* arg);
    void run();

template< typename T >
void* threadpool< T >::worker( void* arg )
{
    threadpool* pool = ( threadpool* )arg;
    pool->run();
    return pool;
}

template< typename T >
void threadpool< T >::run() {

    while (!m_stop) {
        m_queuestat.wait();
        m_queuelocker.lock();
        if ( m_workqueue.empty() ) {//如果工作队列为空；
            m_queuelocker.unlock();
            continue;
        }
        T* request = m_workqueue.front();
        m_workqueue.pop_front();
        m_queuelocker.unlock();
        if ( !request ) {
            continue;
        }
        request->process();
    }

}

整体代码

#ifndef THREADPOOL_H
#define THREADPOOL_H

#include <list>
#include <cstdio>
#include <exception>
#include <pthread.h>
#include "locker.h"

// 线程池类，将它定义为模板类是为了代码复用，模板参数T是任务类
template<typename T>
class threadpool {
public:
    /*thread_number是线程池中线程的数量，max_requests是请求队列中最多允许的、等待处理的请求的数量*/
    threadpool(int thread_number = 8, int max_requests = 10000);
    ~threadpool();
    bool append(T* request);

private:
    /*工作线程运行的函数，它不断从工作队列中取出任务并执行之*/
    static void* worker(void* arg);
    void run();

private:
    // 线程的数量
    int m_thread_number;  
    
    // 描述线程池的数组，大小为m_thread_number    
    pthread_t * m_threads;

    // 请求队列中最多允许的、等待处理的请求的数量  
    int m_max_requests; 
    
    // 请求队列
    std::list< T* > m_workqueue;  

    // 保护请求队列的互斥锁
    locker m_queuelocker;   

    // 是否有任务需要处理
    sem m_queuestat;

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

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(NULL) {

    if((thread_number <= 0) || (max_requests <= 0) ) {
        throw std::exception();
    }

    m_threads = new pthread_t[m_thread_number];
    if(!m_threads) {
        throw std::exception();
    }

    // 创建thread_number 个线程，并将他们设置为脱离线程。
    for ( int i = 0; i < thread_number; ++i ) {
        printf( "create the %dth thread\n", i);
        if(pthread_create(m_threads + i, NULL, worker, this ) != 0) {
            delete [] m_threads;
            throw std::exception();
        }
        //使用之后自己释放资源
        
        if( pthread_detach( m_threads[i] ) ) {
            delete [] m_threads;
            throw std::exception();
        }
    }
}

template< typename T >
threadpool< T >::~threadpool() {
    delete [] m_threads;
    m_stop = true;
}

template< typename T >
bool threadpool< T >::append( T* request )
{
    // 操作工作队列时一定要加锁，因为它被所有线程共享。
    m_queuelocker.lock();
    if ( m_workqueue.size() > m_max_requests ) {
        m_queuelocker.unlock();
        return false;
    }
    m_workqueue.push_back(request);
    m_queuelocker.unlock();
    m_queuestat.post();
    return true;
}

template< typename T >
void* threadpool< T >::worker( void* arg )
{
    threadpool* pool = ( threadpool* )arg;
    pool->run();
    return pool;
}

template< typename T >
void threadpool< T >::run() {

    while (!m_stop) {
        m_queuestat.wait();
        m_queuelocker.lock();
        if ( m_workqueue.empty() ) {
            m_queuelocker.unlock();
            continue;
        }
        T* request = m_workqueue.front();
        m_workqueue.pop_front();
        m_queuelocker.unlock();
        if ( !request ) {
            continue;
        }
        request->process();
    }

}

#endif
三Ⅶ
关注
专栏目录
TongWeb5.0 性能优化配置.pdf
02-11
主要真对JNDI配置和相关性能参数优化，Java调用JNDI代码示例；JVM参数优化；日志参数优化；线程数优化。
线程池自查注意点
徐小冠
12-03 863
​ 该记录首先将介绍线程池的基本概念，在介绍完之后再举例论证当前各项目中存在的线程池创建问题，用以自查。 2、线程池的任务调度流程 （1）如果当前工作线程数量小于核心线程数量，执行器总是优先创建一个任务线程，而不是从线程队列中获取一个空闲线程。（2）如果线程池中总的任务数量大于核心线程池数量，新接收的任务将被加入阻塞队列中，一直到阻塞队列已满。在核心线程池数量已经用完、阻塞队列没有满的场景下，线程池不会为新任务创建一个新线程。（3）当完成一个任务的执行时，执行器总是优先从阻塞队列中获取下一个任务，并开始执
模板使用 线程池
qq_43729554的博客
04-24 240
#ifndef THREADPOOL_H #define THREADPOOL_H //#pragma once #include <list> #include <cstdio> #include <exception> #include <pthread.h> #include "locker.h" // 线程池类，将它定义为模板类是为了代码复用，模板参数T是任务类 template<typename T> class threadpool
tongweb通过控制台简单设置确认相关常用参数
qq_15508731的博客
02-11 2737
1.环境版本 jdk，tongweb版本确认是否正确 2.检查tongweb的 license是不是永久版本，试用期版本到期会停止服务。 3 JVM运行编码配置-根据系统需要配置 4. tongweb运行内存大小--根据系统需要配置 5.http连接数设置调整----根据系统需要配置 ......
【Webserver】——线程池的原理，手写线程池
sjp11的博客
08-07 832
线程池是一种 利用 池化技术思想 来实现的线程管理技术，主要是为了复用线程、便利地管理线程和任务、并将线程的 创建和任务的执行 解耦开来。我们可以创建线程池来复用已经创建的线程来降低频繁创建和销毁线程所带来的资源消耗。
使用C++制作简单的web服务器
09-03
值得注意的是，此Web服务器并未实现HTTP协议的全部特性，例如错误处理、GET请求参数解析、动态内容生成等。此外，服务器没有使用多线程或异步I/O来处理并发请求，因此无法有效地服务多个客户端。如果需要扩展功能，...
Linux下Epoll+线程池的简单Web服务器
01-20
本文将深入探讨如何在Linux环境下使用Epoll和线程池技术构建一个简单的Web服务器。这个Web服务器的实现是基于Linux内核提供的异步I/O模型，Epoll，以及线程池策略，以优化系统资源的使用和提高并发性能。 首先，让...
基于多线程的web服务器
11-28
在IT领域，Web服务器是互联网基础设施的核心组成部分，它们负责...在"基于多线程的WEB服务器.pos"这个文件中，可能包含了进一步的实现细节、代码示例或者性能分析，这些内容有助于深入理解多线程Web服务器的内部运作。
xiaocao.rar_web服务器
09-14
在这个名为"xiaocao.rar_web服务器"的压缩包中，包含了一个名为"xiaocao.java"的源代码文件，我们可以推测这可能是一个简单的Java实现的Web服务器。 首先，让我们深入理解一下Web服务器的工作原理。Web服务器的基本...
（牛客网C++课程）Linux 高并发Web服务器项目实战（带定时检测代码）
02-24
（牛客网C++课程）Linux 高并发Web服务器项目实战（带定时检测代码） 技术框架： 1. 线程池 + 非阻塞 socket + epoll + 事件处理的并发模型 2. 状态机解析HTTP请求 3. 心跳机制 4. 简易日志系统 主要内容： 1. ...
线程池
java、c++、机器学习方向King
01-29 678
知道吗，你的Java web应用其实是使用线程池来处理请求的。这一实现细节被许多人忽略，但是你迟早都需要理解线程池如何使用，以及如何正确地根据应用调整线程池配置。这篇文章的目的是为了解释线程模型——什么是线程池、以及怎样正确地配置线程池。 单线程模型 让我们从一些基础的线程模型开始，然后再随着线程模型的演变进行更深一步的学习。你使用的任何应用服务器或框架，如 Tomcat 、 Drop
Tongweb配置https协议
讓之的博客
06-10 3467
1. 先将证书放到 Tonweb/conf/ 下 2. 启动Tongweb服务器，浏览器访问 找到如下位置，添加http通道 3. 填写基本信息和SSL属性信息 4. 高级属性 如无需修改，点击下一步自动设置为显示默认值 **5.**线程池属性 如无需修改，点击下一步自动设置为显示默认值 **6.**压缩属性 如无需修改，点击下一步自动设置为显示默认值 **7.**其他无需修改，完成即可 ...
Tomcat 线程池
一个菜鸡的博客
07-09 3711
Tomcat 是一个流行的 Java Web 服务器，它使用线程池来处理客户端请求。线程池是一组预先创建的线程，用于执行并发任务，以提高性能和资源利用率。在 Tomcat 中，线程池被用来处理传入的 HTTP 请求。当客户端发送请求时，Tomcat 会从线程池中获取一个可用的线程来处理该请求。处理完请求后，线程将返回线程池，并在下一个请求到来时再次被重用。Tomcat 的线程池配置可以通过编辑server.xml文件来进行。maxThreads：指定线程池中的最大线程数。
Linux网络学习之线程池并发服务器
最新发布
qq_65360223的博客
11-15 77
线程池相关的概念，以及实现的简单和复杂版本的线程池，难度较高
Tongweb优化四步骤
阿鹏哥哥的专栏
10-16 9637
Tongweb优化四步骤   Tongweb优化四步骤（以东方通4.6为例）：1: Java虚拟机jvm内存配置，分配更多的内存给tongweb使用 在服务器环境变量中增加系统变量JAVA_OPTS 参数名 ： JAVA_OPTS 参数值：-Xms128m -Xmx256m
TongWeb上反复重部署应用后异常：application instance has been stopped already 或OutOfMemoryError：Metaspace
web的博客
11-05 7979
TongWeb日志报错如下： java.lang.IllegalStateException: Illegal access: this web application instance has been stopped already. Could not load [redis.clients.util.Pool]. The following stack trace is thrown for debugging purposes as well as to attempt to terminate
TongWeb上的应用系统慢是怎么个慢，死是怎么个死？
热门推荐
web的博客
11-02 1万+
一、问题现象描述 常见的反馈问题说法：现在TongWeb上的应用好慢呀，好像死了。 这种问题描述不够清晰，慢有多种慢的现象，“死”也不是一个专业的说法。下面我们将对这类问题进行分类说明，不同的“死”法，慢法有不同的分析方式。 基本要求：熟悉Linux基本操作、Java编程、JDK基本命令、TongWeb使用，后面我们会用到。 二、“死”的问题 “死”通常是对进程没了或是进程在但没反应而进行的描述。实际是进程崩溃、假死、产生僵尸进程这三类情况，其主要原因有以下几点： 1. 最低级的“死”法 .
Tomcat优化之配置线程池
红颜笑
02-28 561
简介    线程池作为提高程序处理数据能力的一种方案，应用非常广泛。大量的服务器都或多或少的使用到了线程池技术，不管是用Java还是C++实现，线程池都有如下的特点：线程池一般有三个重要参数： 最大线程数。在程序运行的任何时候，线程数总数都不会超过这个数。如果请求数量超过最大数时，则会等待其他线程结束后再处理。最大共享线程数，即最大空闲线程数。如果当前的空闲线程数超过该值，则多余的线程会
创建多线程的方式四：使用线程池
小心星的博客
02-07 251
创建多线程的方式四：使用线程池 package com.day0207_3; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.ThreadPoolExecutor; /** * 创建多线程的方式四：使用线程池 * * 好处: * 1.提高响应速度(减少了创建新线程的时间) * 2.降低资源消耗(重复利用线程池中线程，不
精巧WEB服务器Fire源码解析：基于完成端口技术
资源摘要信息:"精巧的WEB服务器Fire的源代码(采用完成端口)" 知识点: 1. 完成端口模型（IO Completion Port, IOCP）: 完成端口是Windows操作系统中用于异步I/O操作的一种机制。在高并发服务器设计中，完成端口模型...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值