一起来学POSIX thread 之 综合应用——线程池

最新推荐文章于 2024-07-06 14:53:58 发布
最新推荐文章于 2024-07-06 14:53:58 发布
阅读量3k 收藏
点赞数 1
分类专栏： C++ 语言 面向对象设计 Linux&&Unix
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ACb0y/article/details/8581006
版权

一起来学POSIX thread 之 综合应用——线程池

1、为什么需要线程池？

部分应用程序需要执行很多细小的任务，对于每个任务都创建一个线程来完成，任务完成后销毁线程，而这就会产生一个问题：当执行的任务所需要的时间T1小于等于创建线程时间T2和销毁线程时间T3总和时即T1 <= T2 + T3，应用处理任务的响应能力会大大减弱，从而影响了应用程序性能，为了解决这类问题，线程池技术提供了很好的解决方案。线程池顾名思义就是把线程资源池化，在应用启动时一次性创建合适数量的线程，当需要执行任务时就从线程池中分配一个已经创建好的线程来执行，执行完在把线程归还，只在应用停时再一次性销毁所有的线程。

2、线程池的基本组成部分

一个简单的线程池至少包括下列的组成部分：

1）线程池管理器（ThreadPool）:用于创建并管理线程池

2）工作线程（WorkThread）:线程池中线程

3）任务接口（Task）:每个任务必须实行的接口，以供工作线程调度任务执行。

3、Unix下的线程池实现

将给大家展示的线程池实现的类如下：

1）CMutex:互斥量类，对POSIX互斥量的C++封装

2）CAutoMutex:利用C++构造函数和析构函数的特性，实现CAutoMutex变量生命周期内对共享数据的加锁互斥量。

3）CTask:任务的抽象基类，任何具体的任务都要继承该类，并实现自己的void * run()函数。

4）CThread:线程基类，对POSIX线程的C++封装。

5）CWorkThread:工作线程类，实现了执行任务的基本接口

6）CThreadPool:线程池管理类，实现线程的创建管理和任务调度。

一下提供具体实现代码和一个简单的Demo如下：

AutoMutex.h

/**
  *	Author: ACb0y
  *	FileName: AutoMutex.h
  *	CreateTime: 2013年2月14日15:37:12
  *	Version: 1.0
  */

#ifndef __AUTO_MUTEX_LRL_20130214_HEADER__
#define __AUTO_MUTEX_LRL_20130214_HEADER__

#include "Mutex.h"

/*
	
  */
class CAutoMutex
{
///属性
public:
	///nothing.
protected:
	///nothing.
private:
	CMutex * m_pMutex;
	
///构造函数&& 析构函数
public:
	CAutoMutex(CMutex * pMutex)
	{
		m_pMutex = pMutex;
		m_pMutex->lock();
	}
	
	~CAutoMutex()
	{
		m_pMutex->unlock();
	}
protected:
	///nothing.
private:
	///nothing.
	
///服务
public:
	///nothing.
protected:
	///nothing.
private:
	///nothing.
};

#endif

Mutex.h 

/**
  *	Author: ACb0y
  *	FileName: Mutex.h
  *	CreateTime: 2013年2月4日9:33:57
  *	Version: 1.0
  */

#ifndef __MUTEX_LRL_20130204_HEADER__
#define __MUTEX_LRL_20130204_HEADER__

#include <pthread.h>

class CMutex
{
///属性
public:
	///nothing.
protected:
	///nothing.
private:
	pthread_mutex_t m_sMutex;
	
///构造函数&&析构函数
public:
	CMutex(int nShared = PTHREAD_PROCESS_PRIVATE, int nType = PTHREAD_MUTEX_NORMAL);
	~CMutex();
protected:
	///nothing.
private:
	///禁止用户调用拷贝构造函数和赋值操作，调用时会编译报错
	CMutex(const CMutex & cMutex) 
	{
		///nothing.
	}
	CMutex & operator = (const CMutex & cMutex)
	{
		return *this;
	}

///服务
public:
	int lock();
	int unlock();
	int trylock();
protected:
	///nothing.
private:
	///nothing.
};

inline int CMutex::lock()
{
	return pthread_mutex_lock(&m_sMutex);
}

inline int CMutex::unlock()
{
	return pthread_mutex_unlock(&m_sMutex);
}

inline int CMutex::trylock()
{
	return pthread_mutex_trylock(&m_sMutex);
}

#endif

Mutex.cpp 

/**
  *	Author: ACb0y
  *	FileName: Mutex.cpp
  *	CreateTime: 2013年2月4日15:42:15
  *	Version: 1.0
  */


#include "Mutex.h"

CMutex::CMutex(int nShared, int nType)
{
	pthread_mutexattr_t attr;
	pthread_mutexattr_init(&attr);
	pthread_mutexattr_setpshared(&attr, nShared);
	pthread_mutexattr_settype(&attr, nType);
	pthread_mutex_init(&m_sMutex, &attr);
	pthread_mutexattr_destroy(&attr);
}

CMutex::~CMutex()
{
	pthread_mutex_destroy(&m_sMutex);
}

Task.h 

/**
  *	Author: ACb0y
  *	FileName: Task.h
  *	CreateTime: 2013年2月13日23:26:44
  *	Version: 1.0
  */

#ifndef __TASK_LRL_20130213_HEADER__
#define __TASK_LRL_20130213_HEADER__

/*
	抽象任务类
  */
class CTask
{
///属性
public:
	///nothing.
protected:
	///nothing.
private:
	///nothing.

///构造函数&&析构函数
public:
	///nothing.
protected:
	///nothing.
private:
	///nothing.

///服务
public:
	virtual void * run() = 0;
protected:
	///nothing.
private:	
	///nothing.
};


#endif

Thread.h 

/**
  *	Author: ACb0y
  *	FileName: Thread.h
  *	CreateTime: 2013年2月13日12:24:02
  *	Version: 1.0
  */

#ifndef __THREAD_LRL_20130213_HEADER__
#define __THREAD_LRL_20130213_HEADER__

#include <pthread.h>
#include <sched.h>

///定义线程启动函数指针
typedef void * (* pFuncThreadStart)(void *);

/*
	对POSIX线程操作的C++封装
  */
class CThread
{
///属性
public:
	enum EThreadState
	{
		ERR_ALREADERY_INITIALIZED = -6,
		ERR_AT_CREATE_THREAD = -5,
		ERR_AT_CREATE_SEM = -4,
		ERR_NO_TASK = -3,
		ERR_NOT_IDLE = -2,
		UNINITIALIZED = -1,
		IDLE = 0,
		RUNNING = 1,
		QUITED = 9
	};
protected:
	///nothing.
private:
	pthread_t m_nThreadId;
	
///构造函数&&虚构函数
public:
	CThread();
	virtual ~ CThread();
protected:
	///nothing.
private:
	///nothing.
	
///服务
public:
	int create(pFuncThreadStart pFuncStartRoutine, void * pArg, bool bDetached = false, bool bSetScope = false);
	int detach();
	int join(void ** pRetValue = NULL);
	void exit(void * pRetValue = NULL);
	void yield();
	void reset();
	bool isCurrent();
	pthread_t getThreadId();
protected:
	///nothing.
private:
	///nothing.
};

inline pthread_t CThread::getThreadId()
{
	return m_nThreadId;
}

inline int CThread::detach()
{
	return pthread_detach(m_nThreadId);
}

inline int CThread::join(void ** pRetValue)
{
	return pthread_join(m_nThreadId, pRetValue);
}

inline void CThread::exit(void * pRetValue)
{
	if (isCurrent())
	{
		pthread_exit(pRetValue);
	}
}

inline bool CThread::isCurrent()
{
	if (pthread_equal(m_nThreadId, pthread_self()) != 0)
	{
		return true;	///表明是同一线程
	}
	else
	{
		return false;
	}
}

inline void CThread::yield()
{
	sched_yield();
}

inline void CThread::reset()
{
	join();
	m_nThreadId = -1;
}


#endif

Thread.cpp 

/**
  *	Author: ACb0y
  *	FileName: Thread.cpp
  *	CreateTime: 2013年2月13日14:16:20
  *	Version: 1.0
  */

#include "Thread.h"

CThread::CThread() : m_nThreadId(-1)
{
	///nothing.
}

CThread::~CThread()
{
	///nothing.
}

int CThread::create(pFuncThreadStart pFuncStartRoutine, void * pArg, bool bDetached, bool bSetScope)
{
	pthread_attr_t sThread_attr;
	int nStatus;
	nStatus = pthread_attr_init(&sThread_attr);
	if (nStatus != 0)
	{
		return -1;
	}

	if (bDetached)
	{
		nStatus = pthread_attr_setdetachstate(&sThread_attr, PTHREAD_CREATE_DETACHED);
		if (nStatus != 0)
		{
			pthread_attr_destroy(&sThread_attr);
			return -1;
		}
	}

	if (bSetScope)
	{
		nStatus = pthread_attr_setscope(&sThread_attr, PTHREAD_SCOPE_SYSTEM);
		if (nStatus != 0)
		{
			pthread_attr_destroy(&sThread_attr);
			return -1;
		}
	}

	nStatus = pthread_create(&m_nThreadId, &sThread_attr, pFuncStartRoutine, pArg);
	pthread_attr_destroy(&sThread_attr);
	return nStatus;
}

WorkThread.h 

/**
  *	Author: ACb0y
  *	FileName: WorkThread.h
  *	CreateTime: 2013年2月14日12:20:43
  *	Version: 1.0
  */

#ifndef __WORK_THREAD_LRL_20130214_HEADER__
#define __WORK_THREAD_LRL_20130214_HEADER__

#include <semaphore.h>
#include "Thread.h"
#include "Task.h"

/*
	工作线程
  */
class CWorkThread : public CThread
{
///属性
public:
	///nothing.
protected:
	///线程编号
	int m_nNo;
	int m_nStatus;
	sem_t * m_pSem;
	bool m_bNeedQuit;
	bool m_bAutoFinish;
	CTask * m_pTask;
private:
	///nothing.

///构造函数&&析构函数
public:
	CWorkThread(int nNo = 0);
	~CWorkThread();
protected:
	///nothing.
private:
	///nothing.
	
///服务
public:
	int getNo();
	int getStatus();
	///创建线程并将线程挂起
	///调用成功返回IDLE
	int initialize();
	void setTask(CTask * pTask);
	///设置线程执行一次后自动退出
	void setAutoFinish();
	///释放信号量让线程恢复运行，启动成功返回RUNNING
	///当Task执行结束后，线程自动变成IDLE状态
	///如果之前有调用setAutoFinish，则线程自动结束，状态变成了QUITED
	int run();
	///通知并等待线程退出
	void finish();
protected:
	static void * doRun(void * pContext);
private:
	///nothing.
};

inline void CWorkThread::setTask(CTask * pTask)
{
	m_pTask = pTask;
}

inline int CWorkThread::getNo()
{
	return m_nNo;
}

inline int CWorkThread::getStatus()
{
	return m_nStatus;
}

inline void CWorkThread::setAutoFinish()
{
	m_bAutoFinish = true;
}


#endif

WorkThread.cpp 

/**
  *	Author: ACb0y
  *	FileName: WorkThread.cpp
  *	CreateTime: 2013年2月14日13:01:35
  *	Version: 1.0
  */

#include "WorkThread.h"
#include "errno.h"

CWorkThread:: CWorkThread(int nNo)
	:m_pTask(NULL), m_nStatus(UNINITIALIZED), m_bNeedQuit(false), m_bAutoFinish(false), m_nNo(nNo), m_pSem(NULL)
{
	///nothing.
}

CWorkThread::~CWorkThread()
{
	finish();
}

int CWorkThread::initialize()
{
	m_pSem = new sem_t;
	if (m_nStatus != UNINITIALIZED && m_nStatus != QUITED)
	{
		return ERR_ALREADERY_INITIALIZED;
	}

	///创建一个线程间共享初值为0的匿名信号量
	if (sem_init(m_pSem, 0, 0) < 0)
	{
		return ERR_AT_CREATE_SEM;
	}

	if (create(&doRun, (void *)this) < 0)
	{
		return ERR_AT_CREATE_THREAD;
	}

	if (m_bNeedQuit)
	{
		m_bNeedQuit = false;
	}

	if (m_bAutoFinish)
	{
		m_bAutoFinish = false;
	}

	m_nStatus = IDLE;
	return m_nStatus;
}

int CWorkThread::run()
{
	if (m_nStatus != IDLE)
	{
		return ERR_NOT_IDLE;
	}

	if (NULL == m_pTask)
	{
		return ERR_NO_TASK;
	}

	m_nStatus = RUNNING;
	sem_post(m_pSem);
	return m_nStatus;
}

void CWorkThread::finish()
{
	if (m_nStatus != UNINITIALIZED && m_nStatus != QUITED)
	{
		m_bNeedQuit = true;
		sem_post(m_pSem);
		reset();
		sem_destroy(m_pSem);
		delete m_pSem;
		m_pSem = NULL;
	}
}

void * CWorkThread::doRun(void * pArg)
{
	CWorkThread * pWorkThread = (CWorkThread *)pArg;
	CTask * pTask = pWorkThread->m_pTask;
	
	while (!pWorkThread->m_bNeedQuit)
	{
		sem_wait(pWorkThread->m_pSem);
		if (RUNNING == pWorkThread->m_nStatus)
		{
			if (NULL == pTask)
			{
				pWorkThread->m_nStatus = ERR_NO_TASK;
			}
			else
			{
				///执行任务
				pTask->run();	
				pWorkThread->m_nStatus = IDLE;
			}
		}

		if (pWorkThread->m_bAutoFinish)
		{
			pWorkThread->detach();
			break;
		}
	}

	pWorkThread->m_nStatus = QUITED;
	return (void *)0;
}

ThreadPool.h 

 /**
  *	Author: ACb0y
  *	FileName: ThreadPool.h
  *	CreateTime: 2013年2月14日16:13:26
  *	Version: 1.0
  */

#ifndef __THREAD_LRL_20130214_HEADER__
#define __THREAD_LRL_20130214_HEADER__

#include <string.h>
#include "WorkThread.h"
#include "Mutex.h"
#include "AutoMutex.h"

class CThreadPool
{
///属性
public:
	///nothing.
protected:
	///nothing.
private:
	///线程池大小
	int m_nPoolSize;
	///线程池初始处于挂起状态的线程数
	int m_nInitializeCount;
	///活动中的线程数
	int m_nAliveCount;
	///线程数组
	CWorkThread ** m_pThreads;
	///保护线程数组的互斥量
	CMutex m_cMutex;
///构造函数&& 析构函数
public:
	CThreadPool(int nPoolSize = 128, int nInitializeCount = 0);
	~CThreadPool();
protected:
	///nothing.
private:
	///nothing.
	
///服务
public:
	bool postTask(CTask * pTask);
	int getPoolSize();
	int getInitializeCount();
	int getAliveCount();
	void waitAliveFinish();
protected:
	///nothing.
private:
	///nothing.
};

inline int CThreadPool::getPoolSize()
{
	return m_nPoolSize;
}

inline int CThreadPool::getInitializeCount()
{
	return m_nInitializeCount;
}

inline int CThreadPool::getAliveCount()
{
	CAutoMutex cAutoMutex(&m_cMutex);
	return m_nAliveCount;
}

#endif

ThreadPool.cpp 

/**
  *	Author: ACb0y
  *	FileName: ThreadPool.cpp
  *	CreateTime: 2013年2月14日16:57:49
  *	Version: 1.0
  */

#include <iostream>
#include "ThreadPool.h"
using namespace std;

CThreadPool::CThreadPool(int nPoolSize, int nInitializeCount)
	: m_nPoolSize(nPoolSize), m_nInitializeCount(nInitializeCount), m_nAliveCount(0), m_pThreads(NULL)
{
	m_pThreads = new CWorkThread * [nPoolSize];
	if (NULL == m_pThreads)
	{
		return;
	}

	memset(m_pThreads, 0, sizeof(CWorkThread *) * nPoolSize);
	for (int i = 0; i < m_nInitializeCount; ++i)
	{
		m_pThreads[i] = new CWorkThread(i + 1);
		if (NULL == m_pThreads)
		{
			break;
		}
		if (m_pThreads[i]->initialize() != CThread::IDLE)
		{
			break;
		}
		++m_nAliveCount;
	}
}

CThreadPool::~CThreadPool()
{
	if (NULL == m_pThreads)
	{
		return;
	}

	for (int i = 0; i < m_nAliveCount; ++i)
	{
		if (NULL == m_pThreads[i])
		{
			continue;
		}
		m_pThreads[i]->finish();
		delete m_pThreads[i];
		m_pThreads[i] = NULL;
	}
	delete [] m_pThreads;
	m_pThreads = NULL;
}

bool CThreadPool::postTask(CTask * pTask)
{
	bool bPostSuccess = false;
	CAutoMutex cAutoMutex(&m_cMutex);
	for (int i = 0; i < m_nAliveCount; ++i)
	{
		if (m_pThreads[i]->getStatus() == CThread::IDLE)
		{
			m_pThreads[i]->setTask(pTask);
			m_pThreads[i]->run();
			bPostSuccess = true;
			break;
		}
	}

	if (!bPostSuccess && m_nAliveCount < m_nPoolSize)
	{
		m_pThreads[m_nAliveCount] = new CWorkThread(m_nAliveCount + 1);
		if (m_pThreads[m_nAliveCount] != NULL)
		{
			if (m_pThreads[m_nAliveCount]->initialize() == CThread::IDLE)
			{
				m_pThreads[m_nAliveCount]->setTask(pTask);
				m_pThreads[m_nAliveCount]->run();
				++m_nAliveCount;
				bPostSuccess = true;
			}
		}
	}

	return bPostSuccess;
}

void CThreadPool::waitAliveFinish()
{
	if (NULL == m_pThreads)
	{
		return;
	}

	///依次调用所有的活动线程，等待运行结束
	for (int i = 0; i < m_nAliveCount; ++i)
	{
		if (NULL == m_pThreads[i])
		{
			continue;
		}
		m_pThreads[i]->finish();
		delete m_pThreads[i];
		m_pThreads[i] = NULL;
	}

	delete [] m_pThreads;
	m_nAliveCount = 0;
}

Demo文件：ThreadPoolTest.cpp 

#include <iostream>
#include "ThreadPool.h"

using namespace std;

class CTest : public CTask
{
public:
	void * run()
	{
		int nCount = 0;
		while (true)
		{
			sleep(1);
			cout << "[" << ++nCount << "] sleep ..." << endl;
			if (nCount >= 3)
			{
				break;
			}
		}
		sleep(100);
	}
};

int main()
{
	CThreadPool cThreadPool(128,1);
	CTest cTest;
	cThreadPool.postTask(&cTest);
	while (true)
	{
		sleep(4);
		cout << "Current AliveCount = " << cThreadPool.getAliveCount() << endl;
		cThreadPool.postTask(&cTest);
		cout << "Add one task." << endl;
	}
}

附带上makefile文件（所有的源文件放在src目录下，makefile文件放在exe目录下，src，obj，exe为统一目录（ThreadPoolTest）下的目录）： 

MAIN_TARGET=../ThreadPoolTest

SRC_PATH1=../src
SRC_PATH2=../src
OBJ_PATH=../obj

FILE1_1=Thread.cpp
SRC1_1=$(SRC_PATH1)/$(FILE1_1)
OBJ1_1=$(OBJ_PATH)/$(FILE1_1:.cpp=.o)

FILE1_2=WorkThread.cpp
SRC1_2=$(SRC_PATH1)/$(FILE1_2)
OBJ1_2=$(OBJ_PATH)/$(FILE1_2:.cpp=.o)

FILE1_3=Mutex.cpp
SRC1_3=$(SRC_PATH1)/$(FILE1_3)
OBJ1_3=$(OBJ_PATH)/$(FILE1_3:.cpp=.o)

FILE1_4=ThreadPool.cpp
SRC1_4=$(SRC_PATH1)/$(FILE1_4)    
OBJ1_4=$(OBJ_PATH)/$(FILE1_4:.cpp=.o)

FILE2_1=ThreadPoolTest.cpp
SRC2_1=$(SRC_PATH2)/$(FILE2_1)
OBJ2_1=$(OBJ_PATH)/$(FILE2_1:.cpp=.o)

CXX=g++

INCLUDE_PATH=-I$(SRC_PATH1) -I$(SRC_PATH2)

COMPILE_CPP=$(CXX) $(INCLUDE_PATH) -g -o $@ -c $?

COMPILE_LINK=$(CXX) -o  $@ -lpthread

OBJS=$(OBJ1_1) $(OBJ1_2) $(OBJ1_3) $(OBJ1_4) $(OBJ2_1)

$(MAIN_TARGET)::$(OBJS)
	$(COMPILE_LINK) $(OBJS)

$(OBJ1_1)::$(SRC1_1)
	$(COMPILE_CPP)

$(OBJ1_2)::$(SRC1_2)
	$(COMPILE_CPP)

$(OBJ1_3)::$(SRC1_3)
	$(COMPILE_CPP)

$(OBJ1_4)::$(SRC1_4)
	$(COMPILE_CPP)

$(OBJ2_1)::$(SRC2_1)
	$(COMPILE_CPP)
Demo运行结果如下：


运行结果分析如下：初始化创建线程池时，只有一个线程，后续隔4秒就多添加一个任务，此时线程池就动态添加一个线程。


码龙喵
关注
专栏目录
POSIX下简单线程池的实现
私のBookShelf
05-07 220
POSIX下简单线程池的实现 什么是线程池？为什么要有线程池？ 进程是资源分配的基本单位 线程是能独立运行的基本单位 一个进程内的线程共享资源 因此，线程的创建开销小于进程——不需要执行进程复制、分配页表等操作 线程的同步开销小于进程——不需要进程间通信，因为线程之间能共享资源 在客户机-服务器模型中，每当添加一个新的连接时，就需要创建一个新的线程进行响应。当连接结束后，需要释放当前的线程。 线程的开销虽然小，但是并不是意味着没有开销 并且，更加严重的问题是，如果同时有大量连接产生，那么，分配的线程的数量很
Netty学习4——传输
TomWu的博客
06-04 231
传输1.传输API    传输API的核心是interface Channnel，它被用于所有的I/O操作。    每个Channel都将会被分配一个ChannelPipeline和ChannelConfig。ChannelConfig包含了该Channel的所有配置设置，并且支持热更新。由于支持热更新。由于特定的传输可能具有独特的设置，所以它可能会实现一个ChannelConfig的子类型。  ...
C编写的跨平台线程池 - 基于POSIX threads
RIXE
07-05 719
在windows下使用请下载pthreads-win32直接上源码（有比较详细的注释了），threadpool.h/* * Threadpool implementation using pthreads * Copyright (C) 2011 milk
POSIX线程（pthread库）介绍及使用方法
最新发布
热土程序园，利他愉己~
07-06 1282
POSIX线程（pthread库）介绍及使用方法 OSIX线程（POSIX threads），简称Pthreads，是线程的POSIX标准，该标准定义了创建和操纵线程的一整套API。关于pthread.h支持的平台，以下是一些主要的说明： 支持的平台 类Unix系统： Linux：Linux系统广泛支持Pthreads，它是Linux下多线程编程的基础。通过pthread库，开发者可以在Linux环境下创建、管理和同步多个线程。 Unix：传统的Unix系统也支持Pthreads
Java中的线程、进程、多线程的概念
柯基的博客
09-16 370
1、线程（Thread）： 线程是进程的基本执行单元，一个进程的所有任务都在线程中执行 进程要想执行任务，必须得有线程，进程至少要有一条线程 程序启动会默认开启一条线程，这条线程被称为主线程或 UI 线程 2、进程： 进程是指在系统中正在运行的一个应用程序 每个进程之间是独立的，每个进程均运行在其专用的且受保护的内存 3、多线程的意义 优点： 能适当提高程序的执行效率 能适当提高资源的利用率（CPU，内存） 线程上的任务执行完成后，线程会自动销毁 缺点： 开启线程需要占用一定的内存空间（默认情况下，每一个线
C++ posix线程池子
HongDaYu的搬砖之路
05-18 272
#include <pthread.h> #include <iostream> #include <queue> #include <algorithm> #include <cstdint> #include <unistd.h> #include <csignal> typedef void*(*tasks)(void*args); void *master_threads(void *args); class
POSIX多线程——基本线程管理函数介绍
weixin_34199335的博客
07-12 95
POSIX基本的几个线程管理函数见下表： ------------------------------------------------------------------------------------------ POSIX函数...
超详细|一篇搞定操作系统——处理器管理
diviner_s的博客
10-10 6553
文章目录处理器管理2.1 程序执行前趋图前趋图——顺序执行前趋图——并发执行2.2 进程概念与状态2.2.1 进程概念2.2.2 进程的状态2.3 进程控制2.3.1 进程控制块PCB2.3.2 操作系统内核2.3.3 进程控制原语2.4 线程2.4.1 线程的基本概念2.4.2 线程的实现2.4.3 其他相关技术2.5 处理器调度2.5.1 调度的概念2.5.2 作业调度2.5.3 进程调度2.5.4 操作系统调度实例2.6 进程同步和互斥2.6.1 进程同步与互斥概念2.6.2 一些基本概念2.6.3
高级软件工程学习总结
m0_54677380的博客
07-01 609
高级软件工程课程总结与收获
嵌入式初入门——一个项目了解Linux下文件I/O，网络socket编程，多进程，多线程，多路复用（二）
qq_43416810的博客
03-29 340
多进程 上节提到了accpet()函数处理客户端连接时，当有客户端连接时，函数会返回。那么问题来了，这样作为一个服务器就只能给一个客户端服务了，显然这样的服务器就只能拿来自己玩了。那么怎么处理这个多并发问题呢？ 首先可以先用多进程实现，在accept返回后创建一个子进程负责和客户端通信，父进程继续执行accpet()。 进程ID 进程：正在运行的程序及其占用的资源(CPU、内存、系统资源等)叫做进...
linux系统编程之posix线程池
weixin_45050132的博客
08-19 217
【代码】linux系统编程之posix线程池。
linux posix 线程池_linux多线程--POSIX Threads Programming
weixin_35701002的博客
01-15 203
linux多线程自己从接触很久也有不少实践，但总是觉得理解不够深刻，不够系统。借这篇文章试着再次系统学习一下linux多线程编程，理解编程的concept，细致看一下POSIX pthread API的实现。还是凭借强大的google search，找到几篇不错的文章和教程附在最后。我在这篇文章中的总结大多都是基于这些材料的学习和自己实践经验的一点总结。Thread基本知识Process 地址空间...
POSIX Thread
June_we的博客
08-27 306
llnl上关于pthread的一篇tutorial，原文链接https://computing.llnl.gov/tutorials/pthreads/ relative exercise：https://computing.llnl.gov/tutorials/pthreads/exercise.html#Exercise2 部分内容备份： Creating and Destroying ...
POSIX Threads
志汉天涯~！~Day Day Up~
05-27 285
######查看Pthread版本的方法 getconfGNU_LIBPTHREAD_VERSION NativePOSIXThreadLibrary（NPTL）是Linux内核中实践POSIXThreads标准的库。 测试表明，NPTL能够成功地在IA-32平台上在两秒钟内生成100,000个线程；相应的没有NPTL的内核将耗费15分钟左右。 ######linux下pthread实现 参考glibc源码，目录下nptl目录,pthread_*文件...
一文看懂线程池原理及创建（C++实现）
bigchen
09-19 739
  本文给出了一个通用的线程池框架，该框架将与线程执行相关的任务进行了高层次的抽象，使之与具体的执行任务无关。另外该线程池具有动态伸缩性，它 能根据执行任务的轻重自动调整线程池中线程的数量。文章的最后，我们给出一个简单示例程序，通过该示例程序，我们会发现，通过该线程池框架执行多线程任务是多么的简单。 1 为什么需要线程池   目前的大多数网络服务器，包括Web服务器、Email服务器以及数据库服务器等都具有一个共同点，就是单位时间内必须处理数目巨大的连接请求， 但处理时间却相对较短。   传统多线程方案中我
POSIX标准下的线程池的简单实现
m0_38126105的博客
02-04 452
POSIX标准下的线程池的简单实现 一 条件变量操作 函数名 功能 函数原型 pthread_cond_init 条件变量的初始化 int pthread_cond_init(pthread_cond_t*cv,const pthread_condattr_t *cattr)； pthread_cond_wait 等待（阻塞）在条件变量上
基于POSIX实现一个文件下载线程池
prerfect_cat的博客
07-25 171
先理清思路： 线程池需要维护一个任务队列，允许配置活动的线程数，线程池从任务队列中取任务，根据拿到的任务执行响应处理，所以每个任务是这样一个结构体： typedef void* (*FUNC_POINT)(void* arg); //定义一个函数指针 typedef struct Task //任务结构体， { //void* (*Handler)(void* arg); //处理任务...
posix和c++11线程池
05-04 78
posix和c++11线程池
（七） POSIX 线程 ——线程池实例
kitestar的专栏
08-12 538
#include #include #include #include #include #include //线程任务等待链表结构typedef struct worker{void *(*process)(void *arg);void *arg;struct worker *next;}CThread_worker;//线程池结构typedef struct threadpool{pthre
C++实现线程池及pthread简单应用
在C++中，线程池是一种优化的多线程处理形式，它预先创建了一组线程，当有任务需要执行时，可以从线程池中取出一个线程来执行任务，完成后线程返回线程池，而不是立即销毁。线程池的主要优点在于避免了频繁创建和...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值