【网络编程】线程池并发服务器

最新推荐文章于 2022-11-10 15:28:33 发布
最新推荐文章于 2022-11-10 15:28:33 发布
阅读量327 收藏 1
点赞数
分类专栏： 网络编程 Linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CLarali0/article/details/106102478
版权

线程池思路

任务队列作为一个缓冲区，线程池中的线程抢任务。
在这里插入图片描述
threadpool_t结构体

struct threadpool_t {
    pthread_mutex_t lock; 
    pthread_mutex_t thread_counter; //busy_thread_num修改时加解锁
    pthread_cond_t queue_not_full;
    pthread_cond_t queue_not_empty;

    pthread_t *thread; //线程数组
    pthread_t adjust_thread; //管理者线程管理线程池的线程数量
    task_queue_t *task_queue; //任务队列数组

    int min_thread_num;
    int max_thread_num;
    int live_thread_num;
    int busy_thread_num;
    int wait_exit_thread_num;  //等待销毁的线程数

    int queue_front;
    int queue_rear;
    int queue_size; 
    int queue_max_size;

    int shutdown; //shutdown == 0 线程池开，shutdown == 1线程池关
};

task_queue_t结构体

typedef struct { 
    void *(*function)(void *); //回调函数
    void *arg; //参数
} task_queue_t; //任务

main()函数

  1. threadpool_create() 初始化线程池
  2. threadpool_add()向任务队列添加任务
  3. threadpool_destory()
int main() {
    struct threadpool_t *threadpool = threadpool_create(3, 100, 100); //min_thread_num, max_thread_num, queue_max_size
    intptr_t nums[80];
    for (intptr_t i = 0; i < 80; i++) {
        nums[i] = i; //task;
        threadpool_add(threadpool, process, (void *)nums[i]); // 线程池，回调函数，泛型参数
    }
    sleep(10);
    threadpool_destory(threadpool);
    return 0;
}

threadpool_create() 函数初始化threadpool_t

  1. 为int类型的变量赋值
  2. 初始化锁和条件变量
  3. malloc出max_thread_num个thread
  4. 为min_thread_num个线程创建线程pthread_create()，调用func_thread函数
  5. 为管理者线程创建线程，调用func_adjust_thread函数
  6. malloc出queue_max_size个task_queue_t
threadpool_t *threadpool_create(int min_thread_num, int max_thread_num, int queue_max_size){
    struct threadpool_t *pool = (threadpool_t *)malloc(sizeof(threadpool_t));
    do{
        if (pool == NULL) {
            printf("pool malloc failed");
            break; 
        }
		// 为int类型的变量赋值
		pool->min_thread_num = min_thread_num; 
        pool->max_thread_num = max_thread_num;
        pool->live_thread_num = min_thread_num;
        pool->busy_thread_num = 0;
        pool->wait_exit_thread_num = 0;

        pool->queue_front = 0;
        pool->queue_rear = 0;
        pool->queue_size = 0;
        pool->queue_max_size = queue_max_size;

        pool->shutdown = 0;
        //初始化锁和条件变量
        if (pthread_mutex_init(&(pool->lock), NULL) != 0 ||
            pthread_mutex_init(&(pool->thread_counter), NULL) != 0 ||
            pthread_cond_init(&(pool->queue_not_full), NULL) != 0 ||
            pthread_cond_init(&(pool->queue_not_empty), NULL) != 0 ) {
                printf("init the lock or cond failed");
                break; 
        }
        //malloc出max_thread_num个thread
        pool->thread = (pthread_t *)malloc(sizeof(pthread_t) * max_thread_num);
        if (pool->thread == NULL) {
            printf("thread malloc failed");
            break; 
        }
        //赋0
        memset(pool->thread, 0, sizeof(pthread_t) * max_thread_num);
        //为min_thread_num个线程创建线程pthread_create()，调用func_thread函数
        for (int i = 0; i < min_thread_num; i++) {
            pthread_create(&(pool->thread[i]), NULL, func_thread, (void *)pool);
            printf("start thread %ld.\n", pool->thread[i]);
        }
        //为管理者线程创建线程，调用func_adjust函数
        pthread_create(&(pool->adjust_thread), NULL, func_adjust_thread, (void *)pool);
		//malloc出queue_max_size个task_queue_t
        pool->task_queue = (task_queue_t *)malloc(sizeof(task_queue_t) * (pool->queue_max_size));
        if (pool->task_queue == NULL) {
            printf("task_queue malloc failed");
            break; 
        }
		return pool;
    } while(0); // 只执行一次
    
    threadpool_free(pool); // 若前面代码调用失败，free整个空间
    return NULL;
}

threadpool_add()函数向任务队列中添加任务

  1. 添加任务
  2. 发出任务队列不为空的信号
int threadpool_add(threadpool_t *pool, void *(*function)(void *), void *arg) {
	pthread_mutex_lock(&(pool->lock));
	if (pool->shutdown == 1) { 
		pthread_mutex_unlock(&(pool->lock));
		return -1;
	}
	while(pool->queue_size == pool->queue_max_size) {
		pthread_cond_wait(&(pool->queue_not_full), &(pool->lock));
	}
	if (pool->task_queue[pool->queue_rear].arg != NULL) { //防止内存泄露
		free(pool->task_queue[pool->queue_rear].arg);
		pool->task_queue[pool->queue_rear].arg = NULL;
	}
	pool->task_queue[pool->queue_rear].function = function;
	pool->task_queue[pool->queue_rear].arg = arg;
	pool->queue_rear = (pool->queue_rear + 1) % (pool->queue_max_size);
	pool->queue_size++;
	pthread_cond_signal(&(pool->queue_not_empty));
	pthread_mutex_unlock(&(pool->lock));
	return 0;
}

func_thread():普通线程的回调函数

适用场景

  • 线程池初始化时创建min_thread_num个线程
  • 在管理者线程的回调函数中当需要增加线程池线程数量时
  • shutdown == 1 或者 wait_exit_thread_num > 0需要退出线程时，唤醒queue_not_empty，执行pthread_exit(NULL)

流程

  1. 将一个任务出队
  2. 将任务放入线程池中执行，这一步比较抽象，转换成代码就是busy_thread_num++，同时前后加解锁
  3. 任务执行完出线程池，转换成代码就是busy_thread_num--，同时前后加解锁
void* func_thread(void *arg) { //
    threadpool_t *pool = (threadpool_t *)arg;
    task_queue_t task;

    while(1) {
        pthread_mutex_lock(&(pool->lock));

        while ((pool->queue_size) == 0 && (pool->shutdown) == 0) { //task_queue为空
            printf("thread %ld is waiting.\n", pthread_self());
            pthread_cond_wait(&(pool->queue_not_empty), &(pool->lock));

            if (pool->wait_exit_thread_num > 0) { //shudown == 0时结束线程直到只剩最少的线程数
                pool->wait_exit_thread_num--;
                if (pool->live_thread_num > pool->min_thread_num) {
                    printf("thread %ld is exiting.\n", pthread_self());
                    pool->live_thread_num--;
                    pthread_mutex_unlock(&(pool->lock));
                    pthread_exit(NULL); // 先解锁再exit
                }
            }
        }
        while(pool->shutdown) { //shutdown == 1时结束全部线程
            pthread_mutex_unlock(&(pool->lock));
            printf("thread %ld is exiting.\n", pthread_self());
            pthread_exit(NULL);
        }
        //出队
        task.function = pool->task_queue[pool->queue_front].function;
        task.arg = pool->task_queue[pool->queue_front].arg;
        pool->queue_front = (pool->queue_front + 1) % (pool->queue_max_size); // 环形队列
        pool->queue_size--;
        pthread_cond_broadcast(&(pool->queue_not_full));
        pthread_mutex_unlock(&(pool->lock));
        //入线程池
        printf("thread %ld is start working.\n",pthread_self());
        pthread_mutex_lock(&(pool->thread_counter));
        pool->busy_thread_num++;
        pthread_mutex_unlock(&(pool->thread_counter));
        task.function(task.arg); //
        //处理完任务
        printf("thread %ld is end working.\n", pthread_self());
        pthread_mutex_lock(&(pool->thread_counter));
        pool->busy_thread_num--;
        pthread_mutex_unlock(&(pool->thread_counter)); 
    }
    pthread_exit(NULL);
}

func_adjust_thread:管理者线程的回调函数

  1. 何时添加线程池中的线程
  2. 何时减少线程池中的线程。这里减少线程池中的线程的方法很有意思。即先增加wait_exit_thread_num，再唤醒queue_not_empty
void* func_adjust_thread(void* arg) {
    threadpool_t *pool = (threadpool_t *)arg;

    //ques:不进行值的修改为何还需要锁

    while(pool->shutdown == 0) { //线程池未关闭

        sleep(DEFAULT_TIME);

        pthread_mutex_lock(&(pool->lock));
        int live_thread_num = pool->live_thread_num;
        int max_thread_num = pool->max_thread_num;
        int min_thread_num = pool->min_thread_num;
        int queue_size = pool->queue_size;
        pthread_mutex_unlock(&(pool->lock));

        pthread_mutex_lock(&(pool->thread_counter));
        int busy_thread_num = pool->live_thread_num;
        pthread_mutex_unlock(&(pool->thread_counter));

        //add
        if (queue_size > MIN_WAIT_TASK_NUM && live_thread_num < max_thread_num) {
            int add = 0;
            pthread_mutex_lock(&(pool->lock));
            for (int i = 0; (i < max_thread_num) && (add < DEFAULT_STEP) && (live_thread_num < max_thread_num); i++) { //因为并发，所以这里也需要保证<max_thread_num
                if (pool->thread[i] == 0 ) {
                    pthread_create(&(pool->thread[i]), NULL, func_thread, (void*)pool);
                    add++;
                    pool->live_thread_num++; // don't forget
                }
            }
            pthread_mutex_unlock(&(pool->lock));
        }

        //sub
        if (live_thread_num > (2 * busy_thread_num) && live_thread_num > min_thread_num) {
            pthread_mutex_lock(&(pool->lock));
            pool->wait_exit_thread_num = DEFAULT_STEP; // 修改的时候一定要加锁
            pthread_mutex_unlock(&(pool->lock));

            for (int i = 0; i < DEFAULT_STEP; i++) {
                pthread_cond_signal(&(pool->queue_not_empty));
            }
        }
    }
    return NULL;
}

完整代码

#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <pthread.h>
#include <string.h>

#define DEFAULT_STEP 10  
#define MIN_WAIT_TASK_NUM 10
#define DEFAULT_TIME 10

typedef struct { 
    void *(*function)(void *); //回调函数
    void *arg; //参数
} task_queue_t; //任务

struct threadpool_t {
    pthread_mutex_t lock; 
    pthread_mutex_t thread_counter; //busy_thread_num修改时加解锁
    pthread_cond_t queue_not_full;
    pthread_cond_t queue_not_empty;

    pthread_t *thread; //线程数组
    pthread_t adjust_thread; //管理者线程管理线程池的线程数量
    task_queue_t *task_queue; //任务队列数组

    int min_thread_num;
    int max_thread_num;
    int live_thread_num;
    int busy_thread_num;
    int wait_exit_thread_num;  //等待销毁的线程数

    int queue_front;
    int queue_rear;
    int queue_size; 
    int queue_max_size;

    int shutdown; //shutdown == 0 线程池开，shutdown == 1线程池关
};

int threadpool_free(threadpool_t *pool);
int threadpool_destory(threadpool_t *pool);

void* func_thread(void *arg) { //
    threadpool_t *pool = (threadpool_t *)arg;
    task_queue_t task;

    while(1) {
        pthread_mutex_lock(&(pool->lock));

        while ((pool->queue_size) == 0 && (pool->shutdown) == 0) { //task_queue为空
            printf("thread %ld is waiting.\n", pthread_self());
            pthread_cond_wait(&(pool->queue_not_empty), &(pool->lock));

            if (pool->wait_exit_thread_num > 0) { //shudown == 0时结束线程直到只剩最少的线程数
                pool->wait_exit_thread_num--;
                if (pool->live_thread_num > pool->min_thread_num) {
                    printf("thread %ld is exiting.\n", pthread_self());
                    pool->live_thread_num--;
                    pthread_mutex_unlock(&(pool->lock));
                    pthread_exit(NULL); // 先解锁再exit
                }
            }
        }

        while(pool->shutdown) { //shutdown == 1时结束全部线程
            pthread_mutex_unlock(&(pool->lock));
            printf("thread %ld is exiting.\n", pthread_self());
            pthread_exit(NULL);
        }

        //出队
        task.function = pool->task_queue[pool->queue_front].function;
        task.arg = pool->task_queue[pool->queue_front].arg;
        pool->queue_front = (pool->queue_front + 1) % (pool->queue_max_size); // 环形队列
        pool->queue_size--;
        pthread_cond_broadcast(&(pool->queue_not_full));
        pthread_mutex_unlock(&(pool->lock));
        
        //入线程池
        printf("thread %ld is start working.\n",pthread_self());
        pthread_mutex_lock(&(pool->thread_counter));
        pool->busy_thread_num++;
        pthread_mutex_unlock(&(pool->thread_counter));
        task.function(task.arg); //
        
        //处理完任务
        printf("thread %ld is end working.\n", pthread_self());
        pthread_mutex_lock(&(pool->thread_counter));
        pool->busy_thread_num--;
        pthread_mutex_unlock(&(pool->thread_counter)); 
    }
    pthread_exit(NULL);
}

void* func_adjust_thread(void* arg) {
    threadpool_t *pool = (threadpool_t *)arg;

    //ques:不进行值的修改为何还需要锁

    while(pool->shutdown == 0) { //线程池未关闭

        sleep(DEFAULT_TIME);

        pthread_mutex_lock(&(pool->lock));
        int live_thread_num = pool->live_thread_num;
        int max_thread_num = pool->max_thread_num;
        int min_thread_num = pool->min_thread_num;
        int queue_size = pool->queue_size;
        pthread_mutex_unlock(&(pool->lock));

        pthread_mutex_lock(&(pool->thread_counter));
        int busy_thread_num = pool->live_thread_num;
        pthread_mutex_unlock(&(pool->thread_counter));

        //add
        if (queue_size > MIN_WAIT_TASK_NUM && live_thread_num < max_thread_num) {
            int add = 0;
            pthread_mutex_lock(&(pool->lock));
            for (int i = 0; (i < max_thread_num) && (add < DEFAULT_STEP) && (live_thread_num < max_thread_num); i++) { //因为并发，所以这里也需要保证<max_thread_num
                if (pool->thread[i] == 0 ) {
                    pthread_create(&(pool->thread[i]), NULL, func_thread, (void*)pool);
                    add++;
                    pool->live_thread_num++; // don't forget
                }
            }
            pthread_mutex_unlock(&(pool->lock));
        }

        //sub
        if (live_thread_num > (2 * busy_thread_num) && live_thread_num > min_thread_num) {
            pthread_mutex_lock(&(pool->lock));
            pool->wait_exit_thread_num = DEFAULT_STEP; // 修改的时候一定要加锁
            pthread_mutex_unlock(&(pool->lock));

            for (int i = 0; i < DEFAULT_STEP; i++) {
                pthread_cond_signal(&(pool->queue_not_empty));
            }
        }
    }
    return NULL;
}

threadpool_t *threadpool_create(int min_thread_num, int max_thread_num, int queue_max_size){
    struct threadpool_t *pool = (threadpool_t *)malloc(sizeof(threadpool_t));
    do{
        if (pool == NULL) {
            printf("pool malloc failed");
            break; 
        }
		
		pool->min_thread_num = min_thread_num; 
        pool->max_thread_num = max_thread_num;
        pool->live_thread_num = min_thread_num;
        pool->busy_thread_num = 0;
        pool->wait_exit_thread_num = 0;

        pool->queue_front = 0;
        pool->queue_rear = 0;
        pool->queue_size = 0;
        pool->queue_max_size = queue_max_size;

        pool->shutdown = 0;
        
        if (pthread_mutex_init(&(pool->lock), NULL) != 0 ||
            pthread_mutex_init(&(pool->thread_counter), NULL) != 0 ||
            pthread_cond_init(&(pool->queue_not_full), NULL) != 0 ||
            pthread_cond_init(&(pool->queue_not_empty), NULL) != 0 ) {
                printf("init the lock or cond failed");
                break; 
        }
        pool->thread = (pthread_t *)malloc(sizeof(pthread_t) * max_thread_num);
        if (pool->thread == NULL) {
            printf("thread malloc failed");
            break; 
        }
        
        memset(pool->thread, 0, sizeof(pthread_t) * max_thread_num);
        for (int i = 0; i < min_thread_num; i++) {
            pthread_create(&(pool->thread[i]), NULL, func_thread, (void *)pool);
            printf("start thread %ld.\n", pool->thread[i]);
        }
        pthread_create(&(pool->adjust_thread), NULL, func_adjust_thread, (void *)pool);

        pool->task_queue = (task_queue_t *)malloc(sizeof(task_queue_t) * (pool->queue_max_size));
        if (pool->task_queue == NULL) {
            printf("task_queue malloc failed");
            break; 
        }


		return pool;
    } while(0); // 只执行一次
    
    threadpool_free(pool); // 若前面代码调用失败，free整个空间
    return NULL;
}

int threadpool_add(threadpool_t *pool, void *(*function)(void *), void *arg) {
	pthread_mutex_lock(&(pool->lock));
	if (pool->shutdown == 1) {
		pthread_mutex_unlock(&(pool->lock));
		return -1;
	}
	while(pool->queue_size == pool->queue_max_size) {
		pthread_cond_wait(&(pool->queue_not_full), &(pool->lock));
	}
	if (pool->task_queue[pool->queue_rear].arg != NULL) { //important 
		free(pool->task_queue[pool->queue_rear].arg);
		pool->task_queue[pool->queue_rear].arg = NULL;
	}
	pool->task_queue[pool->queue_rear].function = function;
	pool->task_queue[pool->queue_rear].arg = arg;
	pool->queue_rear = (pool->queue_rear + 1) % (pool->queue_max_size);
	pool->queue_size++;
	pthread_cond_signal(&(pool->queue_not_empty));
	pthread_mutex_unlock(&(pool->lock));
	return 0;
}

int threadpool_free(threadpool_t *pool) {
    if (pool == NULL) return -1;
    if (pool->task_queue) {
        free(pool->task_queue);
    }
    if (pool->thread) {
        free(pool->thread);
    }
    pthread_mutex_lock(&(pool->lock));
    pthread_mutex_destroy(&(pool->lock));
    pthread_mutex_lock(&(pool->thread_counter));
    pthread_mutex_destroy(&(pool->thread_counter));
    pthread_cond_destroy(&(pool->queue_not_empty));
    pthread_cond_destroy(&(pool->queue_not_full));
    free(pool); // free释放了一个结构体，但是其中的指针还可以访问
    pool = NULL;
    return 0;
}

int threadpool_destory(threadpool_t *pool) { //此函数为什么不加锁
    if (pool == NULL) return -1;
    pool->shutdown = 1;
    pthread_join(pool->adjust_thread, NULL);
    for (int i = 0; i < pool->live_thread_num; i++) {
        pthread_cond_broadcast(&(pool->queue_not_empty));
    }
    for (int i = 0; i < pool->live_thread_num; i++) { // live_thread_num <= min_thread_num时???
        pthread_join(pool->thread[i], NULL);
    }
    threadpool_free(pool);
    return 0;
}

void* process (void *arg) {
    printf("thread %ld is working %ld task.\n", pthread_self(), (intptr_t)arg);
    sleep(1);
    printf("task %ld is end.\n", (intptr_t)arg);
    return NULL;
}
int main() {
    struct threadpool_t *threadpool = threadpool_create(3, 100, 100);
    printf("threadpool init.\n");
	
    intptr_t nums[80];
    for (intptr_t i = 0; i < 80; i++) {
        nums[i] = i; //task;
        printf("add task %ld\n", nums[i]);
        threadpool_add(threadpool, process, (void *)nums[i]); // 线程池，回调函数，泛型参数
    }
    sleep(10);
    threadpool_destory(threadpool);

    return 0;

}
胖佳儿Clara
关注
专栏目录
线程池并发服务器
log_Li的博客
07-13 167
线程池并发服务器 预先创建阻塞于accept多线程，使用互斥锁上锁保护accept 预先创建多线程，由主线程调用accept struct threadpool_t { pthread_mutex_t lock; /* 用于锁住本结构体 */ pthread_mutex_t thread_counter; /* 记录忙状态线程个数de琐 -- busy_thr_num */ pthread_cond_t queue_not_full;
线程池实现并发服务器
weixin_30664615的博客
10-04 125
1 # 线程池实现并发服务器 2 from multiprocessing.pool import ThreadPool 3 import socket 4 5 6 class Server(object): 7 def __init__(self): 8 self.server = socket.socket() 9 ...
在线词典 | TCP并发服务器（线程池）
leng123123的博客
11-10 1125
线程池实现TCP并发服务器，多客户端连接，进行单词查询功能
线程池网络编程
xx123427的博客
02-09 473
多线程编程中，每有一个新连接时就会创建一个新的线程去维护连接进行收发数据，但是这会有一个问题，就是频繁的线程创造结束会使系统内核的负担加重，对于执行任务的效率也相对低下，因为还要多出创造线程的时间。  那么如何提高效率，减轻内核的负担呢？我们知道主要原因是由于频繁的创建线程。想要改善效率 不可能选择不创建线程。那只能让线程创建的时间提前，并且不会频繁的再结束再创建。因此就有了线程池的提出。   线...
c++实现的线程池并发服务器
12-11
基于linux c++实现的简易的线程池并发服务器，具有参考学习价值。
互联网编程二-多线程线程池TCP服务器端程序设计
最新发布
09-01
自由编写客户端程序和设计测试方式，对1和2中的服务器端程序进行测试，分析比较两个服务器的并发处理能力。 4. 设计编写可重用的服务器日志程序模块，日志记录的内容和日志存储方式可自定（比如可以记录客户端的连接...
轻量级C语言线程池库，可用于网络编程等并发环境
12-17
线程池库适用于任何需要处理并发任务的场景，例如服务器、Web应用程序、多线程应用程序等。它可以帮助开发者更高效地管理线程，避免创建过多的线程，从而降低系统开销和资源消耗。 使用线程池库可以带来以下好处： ...
Linux下基于epoll 线程池高并发服务器实现研究.pdf
09-06
本文的研究结果表明，基于epoll+线程池技术设计出来的高并发服务器可以满足当前网络技术快速发展的需求，能够保证服务器和客户端之间的稳定高效的通信，为当前网络技术的发展提供了有价值的参考。 关键词：Linux...
线程池技术在并发服务器中的应用
08-23
线程池技术在并发服务器中的应用 线程池技术是指在服务器程序中，预先创建一组线程，供客户端请求时使用，以减少创建和销毁线程的开销，提高系统的处理能力。这种技术可以最大程度地利用系统的资源，消除系统因频繁...
Linux + C + Epoll实现高并发服务器(线程池 + 数据库连接池)
09-27
在Linux 系统下面用C 语言实现的高并发服务器的代码，具体用到了Epoll，线程池，数据库连接池。 具体可以看下连接http://blog.csdn.net/wuyuxing24/article/details/48758927
libevent和线程池配合实现的高并发tcp服务器
11-12
全部C代码，linux下的线程池和libevent配合实现的高并发tcp服务器，tcp通讯采用分帧的方式发包，帧包含帧头和数据部分，使用libevent的bufferevent方式来实现的帧提取，可直接使用GCC来编译。还配套有一个C#写的客户端测试程序。 和原来的比有优化，增加了多线程的支持。
网络线程池
07-13
网络游戏线程池模型，可以了解网络游戏中线程池的概念
Linux并发服务器之线程池（thread实现）
xl十一的博客
11-09 509
流程 创建套接字至监听：s 线程池初始化：pool while循环 [1] accept接受连接：c [2] 创建新任务，参数c：task [3] 加入到任务队列：pool.append_task(task) 任务：task 客户端套接字：c echo函数：循环接收客户端消息并回射 锁：mutex 条件变量：myCond 介绍：基于condition_variable实现 函数： [1]...
Unix/Linux 编程:网络编程之 线程池
sesiria的博客
05-05 421
一，线程池的基本组成 1. 工作线程队列 2. 任务队列 3. 线程管理器（封装了线程池的一些基本方法，创建，销毁，加入新任务等) 比如一个常用的网络服务，通常主循环用于处理接收与基本的recv/send操作。可是如果某些业务操作需要长时间的处理数据。 比如等待数据库查询结果，对数据进行编解码等业务逻辑事。为了不让主线程进行长时间的阻塞，从而引入了线程池。让线程池的工作队列来处理具体的业务。 主线程则继续处理网络连接。 应用：线程池是生产者与消费者模型的一个最典型的应用。最常见的ngin.
socket网络编程(四)-----基于线程池的并发服务器
weixin_44918162的博客
01-16 713
服务器主线程在每收到客户端连接请求，创建一个工作线程，这会消耗服务器CPU资源，从而降低客户端的连接响应速度。服务器开启监听之前，可以预先创建工作线程，通过线程池管理这些线程。初始时，线程池可用的连接描述符为0，此时工作线程阻塞在取描述符中，当有连接请求时，主线程将accept()获得的描述符插入线程池，其中某一个工作线程会立马跳出阻塞，从线程池中取得描述符，然后开始和客户端通信。 服务器端： #...
线程池和进程池即池实现并发服务器
weixin_30455365的博客
08-18 101
可重复利用的线程（关于队列计数器，可参考这里） from queue import Queue from threading import Thread class MyThread(Thread): # 继承线程类 def __init__(self): super().__init__() # 继承类中的属性 ...
Java并发编程之基于线程池技术的简单Web服务器
样young的博客
06-02 1715
      目前大多浏览器都支持多线程访问，但是如果Web服务器是单线程的话，多线程的浏览器也无用武之地，因为服务端只能一个请求一个请求的顺序处理。因此，Web服务器很有必要支持并发访问。下面通过使用线程池构造一个简单的Web服务器，这个服务器可以处理HTTP请求，并处理简单的文本和jpg格式图片内容。当客户端不断请求Socket连接，Web服务器将该连接以及请求提交线程池处理，使得Web服务器能...
Linux网络编程——线程池
qq_37233070的博客
04-09 371
一、传统线程工作方式 传统线程工作方式: 接收消息 ==> 消息分类 ==> 线程创建 ==> 传递消息到子线程 ==> 线程分离 ==> 在子线程中执行任务 ==> 子线程任务结束 ==> 销毁子线程； 当面临大量消息频繁请求服务器的情况时，会频繁的创建与销毁线程，而这是一种奢侈的开销，特别对于嵌入式服务器来说更应保证内存资源的合理利用； 为了适当解决这一过程，催生出了线程池（threadpool）。 线程池允许一...
Java5并发编程：线程池实现网络服务器模型
通过构建一个网络服务器模型，展示了如何使用这些工具优化并发性能。" Java多线程在Java 5版本中得到了显著增强，引入了`java.util.concurrent`并发包，这个包为开发高效并发应用程序提供了丰富的API。其中，线程池...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值