线程池

最新推荐文章于 2024-07-19 16:55:35 发布

Mrsw

最新推荐文章于 2024-07-19 16:55:35 发布

阅读量149

点赞数

分类专栏： linux 文章标签：多线程

本文链接：https://blog.csdn.net/weixin_43554618/article/details/106129685

版权

linux 专栏收录该内容

17 篇文章 0 订阅

订阅专栏

线程池

1.线程池

线程池：线程的池子，有很多线程，但是数量不会超过池子的限制。需要用到多执行流进行任务处理的时候，就从池子中取出一个线程去处理。

应用场景：有大量的数据处理请求，需要多执行流并发/并行处理。

实现：一堆线程+线程安全的任务队列，然后不断取出任务进行处理。

如果一次数据请求的到来伴随一个线程的创建去处理，则会产生一些风险以及一些不必要的消耗：

1.线程若不限制数量的创建，在峰值压力下，线程创建过多，资源耗尽，有程序崩溃的风险。

2.每次创建线程和销毁线程都需要时间。线程池使用已经创建好的线程进行循环任务处理，就避免了大量线程的频繁创建与销毁成本。

具体代码实现

//threadpool.hpp
#include<cstdio>
#include<iostream>
#include<queue>
#include<pthread.h>
#include<stdlib.h>
typedef void(*handler_t)(int);
class ThreadTask
{
	public:
		void SetTask(int data, handler_t handler)
		{
			_data = data;
			_handler = handler;
		}
		void Run()
		{
			return _handler(_data);
		}
	private:
		int _data;
		handler_t _handler;
};
class ThreadPool
{
	public:
		ThreadPool(int max_thr = 5)
			:_thr_max(max_thr)
		{
			pthread_mutex_init(&_mutex, NULL);
			pthread_cond_init(&_cond, NULL);
			for(int i = 0;i < _thr_max;i++)
			{
				pthread_t tid;
				int ret = pthread_create(&tid, NULL, thr_start, (void*)this);
				if(ret != 0)
				{
					printf("create error\n");
					exit(-1);
				}
			}
		}
		~ThreadPool()
		{
			pthread_mutex_destroy(&_mutex);
			pthread_cond_destroy(&_cond);
		}
		bool TaskPush(ThreadTask& task)
		{
			pthread_mutex_lock(&_mutex);
			_queue.push(task);
			pthread_mutex_unlock(&_mutex);
			pthread_cond_broadcast(&_cond);
			return true;
		}
		static void* thr_start(void* arg)
		{
			ThreadPool* p = (ThreadPool*)arg;
			while(1)
			{
				pthread_mutex_lock(&p->_mutex);
				while(p->_queue.empty())
				{
					pthread_cond_wait(&p->_cond, &p->_mutex);
				}
				ThreadTask task;
				task = p->_queue.front();
				p->_queue.pop();
				pthread_mutex_unlock(&p->_mutex);
				task.Run();
			}
			return NULL;
		}
	private:
		int _thr_max;
		std::queue<ThreadTask> _queue;
		pthread_mutex_t _mutex;
		pthread_cond_t _cond;
};

//main.cpp
#include "threadpool.hpp"
#include<unistd.h>
void func1(int data)
{
	int sec = (data % 3) + 1;
	printf("tid:%p--data:%d--sec:%d\n", pthread_self(), data, sec);
	sleep(sec);
}
void func2(int data)
{
	printf("tid:%p--data:%d\n", pthread_self(), data);
	sleep(1);
}
int main()
{
	ThreadPool p;
	for(int i = 0;i < 10;i++)
	{
		ThreadTask task;
		if(i % 2 == 0)
			task.SetTask(i, func1);
		else
			task.SetTask(i, func2);
		p.TaskPush(task);
	}
	sleep(1000);
	return 0;
}

2.线程安全的单例模式

单例模式：是非常经典的、常用的一种设计模式。

一份资源只能被申请加载一次/单例模式的方法创建的类在当前进程中只有一个实例。

饿汉方式实现单例模式

饿汉方式：资源在程序初始化的时候就去加载，使用的时候就能直接使用。使用的时候比较流程，有可能会加载用不上的资源，并且会导致程序初始化的时间比较慢。

使用static就可以将一个成员变量设置为静态变量，所有对象共用一份资源，并且在程序初始化时就会申请资源。

#include<cstdio>
class temp
{
public:
        int* get_data()
        {
                return &_data;
        }
private:
        static int _data;
};

int temp::_data = 1;

int main()
{
        temp a;
        temp b;
        printf("a:%d-%p\n", *(a.get_data()), a.get_data());
        printf("b:%d-%p\n", *(b.get_data()), b.get_data());
        return 0;
}

懒汉方式实现单例模式

懒汉方式：资源在使用的时候发现还没有加载，则申请加载。程序初始化比较快，第一次运行某个模块的时候就会比较慢，因为这个时候去加载相应资源。

使用static就可以将一个成员变量设置为静态变量，所有对象共用一份资源，并且在运行时才会申请资源。

#include<cstdio>
#include<thread>
#include<mutex>
std::mutex lock;
class temp
{
public:
        volatile int* get_data()
        {
                if(_data == NULL)
                {
                        lock.lock();
                        if(_data == NULL)
                        {
                                _data = new int;
                                *_data = 10;
                        }
                        lock.unlock();
                }
                return _data;
        }
private:
        volatile static int* _data;
};
volatile int* temp::_data = NULL;


int main()
{
        temp a;
        temp b;
        printf("a:%d-%p\n", *(a.get_data()), a.get_data());
        printf("b:%d-%p\n", *(b.get_data()), b.get_data());
        return 0;
}