linux的多任务编程-线程池,Linux的多任务编程-线程池(转)

最新推荐文章于 2024-08-12 20:16:40 发布
最新推荐文章于 2024-08-12 20:16:40 发布
阅读量153 收藏
点赞数
文章标签： linux的多任务编程-线程池

任务队列控制的线程模型主要是通过任务队列上的信号来控制线程池中的线程调度.

线程池的实现

本例程共由5个文件构成:tpool.h,tpool.c,log.c,log.h,testpool.c.其中tpool.h,tpool.c是实现线程池的核心文件,在tpool.h中定义了线程池和工作线程的数据结构及创建线程池和添加工作线程等方法,tpool.c中为具体的实现代码.log.c,log.h提供了一种记录文件的生成手段,能在文件中记录自定义的信息.testpool.c为线程池的测试程序.

该例子由多个源文件组成,编译命令如下:gcc -g -pthread -o testpool testpool.c

tpool.c log.c

下面给出这个例子的源代码,首先是线程池的定义文件tpool.h:

#ifndef _TPOOL_H_

#define _TPOOL_H_

#include

#include

typedef struct tpool_work

{

void (*handler_routine)();

void *arg;

struct tpool_work *next;

} tpool_work_t;

typedef struct tpool

{

int num_threads;

int max_queue_size;

int do_not_block_when_full;

pthread_t *threads;

int cur_queue_size;

tpool_work_t *queue_head;

tpool_work_t *queue_tail;

pthread_mutex_t queue_lock;

pthread_cond_t queue_not_full;

pthread_cond_t queue_not_empty;

pthread_cond_t queue_empty;

int queue_closed;

int shutdown;

} tpool_t;

extern tpool_t *tpool_init(int num_worker_threads,\

int max_queue_size, int

do_not_block_when_full);

extern int tpool_add_work(tpool_t *pool, void

(*routine)(), void *arg);

extern int tpool_destroy(tpool_t *pool, int finish);

#endif

当线程池退出后,需要释放所用的资源,包括以下五个步骤:

设置线程退出标记;

禁止添加新任务到任务链表;

设置线程池销毁标记;

等待所有已经建立的线程退出;

释放线程池所占的内存空间.

int tpool_destroy(tpool_t *pool, int finish)

{

int i, rtn;

tpool_work_t *cur;

lprintf(log, INFO,

"destroy pool begin!\n");

if((rtn =

pthread_mutex_lock(&(pool->queue_lock))) != 0)

{

lprintf(log,FATAL,"pthread mutex lock

failure\n");

return -1;

}

lprintf(log, INFO,

"destroy pool begin 1!\n");

if(pool->queue_closed

|| pool->shutdown)

{

if((rtn =

pthread_mutex_unlock(&(pool->queue_lock))) !=

0)

{

lprintf(log,FATAL,"pthread mutex lock failure\n");

return

-1;

}

return 0;

}

lprintf(log, INFO,

"destroy pool begin 2!\n");

pool->queue_closed =

1;

if(finish)

{

while(pool->cur_queue_size !=

0)

{

if((rtn =

pthread_cond_wait(&(pool->queue_empty),&(pool->queue_lock)))

!= 0)

{

lprintf(log,FATAL,"pthread_cond_wait %d\n",rtn);

return -1;

}

}

}

lprintf(log, INFO,

"destroy pool begin 3!\n");

pool->shutdown =

1;

if((rtn =

pthread_mutex_unlock(&(pool->queue_lock))) !=

0)

{

lprintf(log,FATAL,"pthread mutex unlock

failure\n");

return -1;

}

lprintf(log, INFO,

"destroy pool begin 4!\n");

if((rtn =

pthread_cond_broadcast(&(pool->queue_not_empty))) !=

0)

{

lprintf(log,FATAL,"pthread_cond_boradcast

%d\n",rtn);

return -1;

}

if((rtn =

pthread_cond_broadcast(&(pool->queue_not_full)))

!= 0)

{

lprintf(log,FATAL,"pthread_cond_boradcast

%d\n",rtn);

return -1;

}

for(i = 0; i <

pool->num_threads; i++)

{

if((rtn =

pthread_join(pool->threads[i],NULL)) != 0)

{

lprintf(log,FATAL,"pthread_join %d\n",rtn);

return

-1;

}

}

free(pool->threads);

while(pool->queue_head != NULL)

{

cur = pool->queue_head->next;

pool->queue_head =

pool->queue_head->next;

free(cur);

}

free(pool);

lprintf(log, INFO,

"destroy pool end!\n");

return 0;

}

函数tpool_thread定义了工作线程的函数,其中真正与实际任务有关的只有一行代码:

(*(my_work->handler_routine))(my_work->arg);

即执行my_work->handler_routine指针指向的函数,并传入参数my_work->arg.其他的步骤都是为执行这个任务而进行的各种设置和准备.

void *tpool_thread(void *tpool)

{

tpool_work_t

*my_work;

tpool_t *pool = (struct

tpool *)tpool;

for(;;)

{

pthread_mutex_lock(&(pool->queue_lock));

while((pool->cur_queue_size == 0) &&

(!pool->shutdown))

{

pthread_cond_wait(&(pool->queue_not_empty),

&(pool->queue_lock));

}

if(pool->shutdown)

{

pthread_mutex_unlock(&(pool->queue_lock));

pthread_exit(NULL);

}

my_work = pool->queue_head;

pool->cur_queue_size--;

if(pool->cur_queue_size == 0)

pool->queue_head = pool->queue_tail = NULL;

else

pool->queue_head = my_work->next;

if((!pool->do_not_block_when_full)

&&\

(pool->cur_queue_size ==

(pool->max_queue_size - 1)))

{

pthread_cond_broadcast(&(pool->queue_not_full));

}

if(pool->cur_queue_size ==

0)

{

pthread_cond_signal(&(pool->queue_empty));

}

pthread_mutex_unlock(&(pool->queue_lock));

(*(my_work->handler_routine))(my_work->arg);

free(my_work);

}

return(NULL);

}

工作状态的记录

为了便于记录线程池的工作状态,还实现了一个记录服务器.该记录服务器实现了一中类似syslog的日志功能,总共就三个函数,使用十分简单.

log.h是该记录服务器的头文件.

#ifndef __LOG_H

#define __LOG_H

#include

#include

#define LOGLINE_MAX 1024

#define DEBUG 1

#define INFO  2

#define WARN  3

#define ERROR 4

#define FATAL 5

#define LOG_TRUNC  1<<0

#define LOG_NODATE  1<<1

#define LOG_NOLF  1<<2

#define LOG_NOLVL  1<<3

#define LOG_DEBUG  1<<4

#define LOG_STDERR  1<<5

#define LOG_NOTID  1<<6

typedef struct

{

int fd;

sem_t sem;

int flags;

} log_t;

int lprintf( log_t *log, unsigned int level, char *fmt, ...

);

log_t *log_open( char *fname, int flags );

void log_close( log_t *log );

#endif

该记录服务器和线程池没有直接的关系,如果有需要,可以很方便的该记录服务器移植到自己的项目中.

lprintf函数的功能是打印记录,log指针指向了一个通过log_open函数打开的记录文件,所有的记录信息都将保存在这个文件中.通过level参数指定记录内容的分类,在log.h中定义了6种分类,分别是:DEBUG,INFO,WARN,ERROR和FATAL,便于对大量的记录信息进行分类.

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include "log.h"

int lprintf( log_t *log, unsigned int level, char *fmt, ...

)

{

int fd;

int rc;

va_list ap;

time_t now;

char date[50];

static char

line[LOGLINE_MAX];

static char

threadnum[10];

int cnt;

static char *levels[6] =

{ "[(bad)] ", "[debug] ", "[info ] ", "[warn ] ",

"[error] ", "[fatal] " };

if(!log) return

-1;

if(

!(log->flags&LOG_DEBUG) && level == DEBUG ) return

0;

fd=log->fd;

if(

!(log->flags&LOG_NODATE) )

{

now=time(NULL);

strcpy(date,ctime(&now));

date[strlen(date)-6]=' ';

date[strlen(date)-5]='\0';

}

if(

!(log->flags&LOG_NOTID) )

{

sprintf(threadnum, "(TID:%lu) ",

pthread_self());

}

cnt = snprintf(line,

sizeof(line), "%s%s%s",

log->flags&LOG_NODATE ? "" : date,

log->flags&LOG_NOLVL  ? ""

:

(level

> FATAL ? levels[0] : levels[level]),

log->flags&LOG_NOTID  ? "" :

threadnum);

va_start(ap, fmt);

vsnprintf(line+cnt,

sizeof(line)-cnt, fmt, ap);

va_end(ap);

line[sizeof(line)-1] =

'\0';

if(

!(log->flags&LOG_NOLF) )

{

}

sem_wait(&log->sem);

rc = write(fd, line,

strlen(line));

if

(log->flags&LOG_STDERR)

write(2, line, strlen(line));

sem_post(&log->sem);

if( !rc ) errno =

0;

return rc;

}

log_open函数的作用是打开一个记录文件,其作用与fopen函数类似.

log_t *log_open( char *fname, int flags

)

{

log_t *log =

malloc(sizeof(log_t));

if(!log)

{

fprintf(stderr, "log_open: Unable to

malloc()");

goto log_open_a;

}

log->flags=flags;

if( !strcmp(fname,"-")

)

{

log->fd = 2;

}

else

{

log->fd = open(fname,

O_WRONLY|O_CREAT|O_NOCTTY |

(flags&LOG_TRUNC ?

O_TRUNC : O_APPEND) , 0666);

}

if( log->fd == -1

)

{

fprintf(stderr, "log_open: Opening logfile %s:

%s", fname, strerror(errno));

goto log_open_b;

}

if(

sem_init(&log->sem, 0, 1) == -1 )

{

fprintf(stderr, "log_open: Could not initialize

log semaphore.");

goto log_open_c;

}

return log;

log_open_c:

close(log->fd);

log_open_b:

free(log);

log_open_a:

return NULL;

}

log_close函数的作用是关闭一个打开的记录文件.通常在函数退出的时候执行这个函数,以保证所有记录信息都正确的写入记录文件.

void log_close( log_t *log )

{

sem_wait(&log->sem);

sem_destroy(&log->sem);

close(log->fd);

free(log);

return;

}

log_open函数的作用是打开一个记录文件,其作用与fopen函数类似.

log_t *log_open( char *fname, int flags

)

{

log_t *log =

malloc(sizeof(log_t));

if(!log)

{

fprintf(stderr, "log_open: Unable to

malloc()");

goto log_open_a;

}

log->flags=flags;

if( !strcmp(fname,"-")

)

{

log->fd = 2;

}

else

{

log->fd = open(fname,

O_WRONLY|O_CREAT|O_NOCTTY |

(flags&LOG_TRUNC ?

O_TRUNC : O_APPEND) , 0666);

}

if( log->fd == -1

)

{

fprintf(stderr, "log_open: Opening logfile %s:

%s", fname, strerror(errno));

goto log_open_b;

}

if(

sem_init(&log->sem, 0, 1) == -1 )

{

fprintf(stderr, "log_open: Could not initialize

log semaphore.");

goto log_open_c;

}

return log;

log_open_c:

close(log->fd);

log_open_b:

free(log);

log_open_a:

return NULL;

}

log_close函数的作用是关闭一个打开的记录文件.通常在函数退出的时候执行这个函数,以保证所有记录信息都正确的写入记录文件.

void log_close( log_t *log )

{

sem_wait(&log->sem);

sem_destroy(&log->sem);

close(log->fd);

free(log);

return;

}

线程池的测试

#include

#include "log.h"

#include "tpool.h"

log_t *log;

void thread(void *arg)

{

char * ptr=(char *)arg;

sleep(1);

printf("hello world! %s\n",ptr);

}

int main(int argc, char *argv[])

{

tpool_t *pool;

log=log_open("test.log",

0);

pool=tpool_init(100,200,1);

int i;

* 添加100个任务*/

for (i = 0;

i<100;i++)

tpool_add_work(pool,thread,"test!");

sleep(10);

tpool_destroy(pool,1);

log_close(log);

pthread_exit(NULL);

}

该例子演示了如何建立一个线程池,以及如何记录程序的运行状态,有一定的使用意义,稍加修改就可以应用到实际的项目中.能理解其中的设计思想和技巧,对自己编程能力的提高有很大的提高

应钟有微
关注
Linux系统编程：线程池编程
凯凯在此
08-15 413
文章目录1. 构成1.1 任务队列 `job_queue`1.2 工作线程 `worker`1.3 线程池 `thread_pool`2. 流程3. 实例 为什么使用线程池？ 频繁创建和销毁线程浪费CPU资源 线程是什么？ 一堆线程放在一个池子里统一管理 1. 构成 类似于银行柜台的流程 1.1 任务队列 job_queue 作用： 存放待处理的任务 成员： 构成 接口 处理函数 void *(*)(void*) 参数 void *arg 队列指
Linux多线程C++工具库：liblmp_tool -- 线程池类ThreadPool
cyf15238622067的博客
05-31 342
Linux多线程编程工具库liblmp_tool github:https://github.com/Dwyane05/liblmp_tool 使用条件变量和互斥锁实现线程池： 头文件： /* * Use of this source code is governed by a BSD-style license * that can be found in the Li...
Linux多任务编程（二）---fork()函数及其基础实验
王文松的博客
06-08 4450
fork()函数      在 Linux 中创建一个新进程的唯一方法是使用fork()函数。fork()函数是 Linux 系统中一个非常重要的函数，和咱们以前遇到过的函数由一些区别，因为它看起来执行一次却返回两个值，这又作何解释？不着急，慢慢看。 函数说明    fork()函数用于从已存在的一个进程中创建一个新的进程，新进程称为子进程，而原进程称为父进程。使用fork()函数得到的子进
Linux系统编程（7）多任务编程：进程
最新发布
weixin_68239724的博客
08-12 872
进程是正在运行中的程序，或者说是一次程序的执行过程。程序是死的，进程是活的，程序是存储在硬盘上的，进程是运行在内存中的，一个程序可以对应多个进程。程序加载到内存中就成为了进程。
Linux的多任务编程-进程
ithome
09-16 236
Linux的多任务编程-进程 进程的概念 进程是指一个具有独立功能的程序在某个数据集合上的一次动态执行过程,它是系统进行资源分配和调度的基本单元.一次任务的运行可以并发激活多个进程,这些进程相互合作来完成该任务的一个最终目标. 进程的特性:并发性,动态性,交互性,独立性,异步性. 进程的种类:交互式进程,批处理进程,实时进程. 进程和程序是有本质区别的:程序是静态的一段代码,是一些保存在非...
linux的多任务编程-线程池,linux的多任务编程-线程池
weixin_42134143的博客
05-08 201
linux的多任务编程-线程池嵌入式开发交流群280352802，欢迎加入！简介在嵌入式系统环境下,由于系统资源和任务的特点,多线程成了实现多任务处理的重要方式.在一些常见的应用环境中,如Web服务器,Email服务器以及数据库服务器等都具有一个共同点:单位时间内必须处理很多并发的连接请求,但处理时间却相对较短.传统多线程方案中我们采用的服务器模型则是一旦接受到请求之后,即创建一个新的线程,由该线...
Linux多任务编程
slgcsdn的博客
06-12 192
进程的控制 1.进程的创建 任何一个用户进程的创建都是由现有的一个进程完成的，进程的创建要经过fork和exec两个过程。 fork是为新进程分配相应的数据结构，并将父进程的相应上下文信息复制过来。 exec是将可执行文件的正文和数据转入内存覆盖它原来的（从父进程复制过来的），并开始执行正文段。（把当前进程替换为一个新进程），在使用这些系统调用的程序中要加入以下头文件和外部变量： #include extern char **environ; 参数表的传递有关（l表示（list）,v表...
C-epoll-连接池-线程池.zip
08-12
其次，线程池是一种多线程处理形式，预先创建了一组线程，当有任务需要执行时，从线程池中获取空闲线程，执行任务后线程返回线程池。这种方式避免了频繁创建和销毁线程的开销，提高了系统的响应速度。在本项目中，...
linux下C语言实现线程池
12-25
线程池是一种多线程处理形式，预先创建一组线程，待有任务时分配给这些线程执行，而不是每次需要时创建新的线程。这种设计模式提高了程序的效率，减少了线程创建和销毁的开销。接下来，我们将深入探讨如何在Linux...
linux 实现一个简单的线程池及工作
03-30
linux 实现一个简单的线程池及工作 本实例演示了线程池的创建使用
linux多任务编程
pingxiaozhao的博客
12-26 684
1.fork()函数 fork()函数用于从已经从在的进程中创建一个新进程。新进程为子进程，原进程为父进程。在父进程中执行fork()函数时，父进程会复制出一个子进程，而且父子进程的代码从fork()函数的返回开始分别在两个地址空间中同时运行，从而使两个进程分别获得其所属fork()函数的返回值，其中在父进程中的返回值是子进程的进程号，而在子进程中返回0。因此，可以通过返回值来判断是父进程还是子进程。 使用fork()函数的代价是很大的，它复制了父进程中的代码段、数据段和堆栈段里的大部分内容，使用for
Linux多任务编程（一）
apple_71040140的博客
08-24 350
为什么学习多进程线程：在我们学习该课程之前，我们代码的执行逻辑，从上往下，一条一条语句执行: 先干什么，后干什么。学习多线程进程，可以实现多任务同时运行，互相切换互不影响，拜托传统代码逻辑执行的弊端。任务会频繁切换给用户多个任务一同运行的感觉。什么是任务：简单讲：一个任务就是一个程序的一次运行，一个任务包含一个或者多个独立功能的子任务，这个独立的子任务是进程或者线程。进程是程序执行和资源管理的最小单位，是一个动态的概念，它是程序执行的过程，包括创 建、调度和消亡。1.1.2 什么是程序。
linux系统编程之多任务编程
z1zyy的博客
11-22 768
linux 多进程编写
Linux多任务编程（一）---任务、进程、线程
王文松的博客
06-08 9418
Linux下多任务介绍   首先，先简单的介绍一下什么叫多任务系统？任务、进程、线程分别是什么？它们之间的区别是什么？，从而可以宏观的了解一下这三者，然后再针对每一个仔细的讲解。    什么叫多任务系统？多任务系统指可以同一时间内运行多个应用程序，每个应用程序被称作一个任务。    任务定义:任务是一个逻辑概念,指由一个软件完成的任务，或者是一系列共同达到某一目的的操作。    进程定义:...
Linux 多任务编程——多线程实现多任务
Hamlee67的博客
03-26 337
概述 每个进程都拥有自己的数据段、代码段和堆栈段，这就造成进程在进行创建、切换、撤销操作时，需要较大的系统开销。为了减少系统开销，从进程中演化出了线程。为了让进程完成一定的工作，进程必须至少包含一个线程。线程存在于进程中，共享进程的资源。更多详情，请看《进程和线程的区别与联系》。 就像每个进程都有一个进程号一样，每个线程也有一个线程号。进程号在整个系统中是唯一的，但线程号不同，线程号只在它所属的...
Linux多线程编程指南
"Linux多线程编程手册.pdf" 在Linux环境下进行多线程编程是一项复杂的任务，需要深入理解操作系统内核、内存管理以及并发控制机制。《Linux多线程编程手册》是一份详尽的参考资料，旨在帮助程序员在Linux系统中高效...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值