【Linux】POSIX 线程信号量与互斥锁▲

//信号量的值减去一个“1”

int  sem_wait (sem_t *sem);

4.销毁

int  sem_destroy (sem_t *sem);

二、线程互斥量

1.初始化

int pthread_mutex_init (pthread_mutex_t* mutex, const pthread_mutexattr_t* mutexattr);

2.加锁

int pthread_mutex_lock (pthread_mutex_t* mutex);

3.解锁

int pthread_mutex_unlock(pthread_mutex_t* mutex);

4.销毁

int pthread_mutex_destroy(pthread_mutex_t* mutex);

三、两者之间的区别：

1. 资源访问数量限制

• 线程信号量：可以允许多个线程同时访问共享资源，具体数量由信号量的初始值决定。例如，若信号量初始值为 3，那么最多允许 3 个线程同时访问共享资源。
• 线程互斥锁：同一时间只允许一个线程访问共享资源，起到独占访问的作用。

2. 用途场景

• 线程信号量：适用于多个资源实例的情况，如多个数据库连接、多个文件句柄等。它可以控制并发访问的线程数量，避免资源耗尽。
• 线程互斥锁：主要用于保护临界区，防止多个线程同时访问共享资源而导致的数据不一致问题，如对共享变量的读写操作。

四、条件变量

这些 POSIX 线程库中与条件变量相关的函数，若执行成功，通常返回值为 0；若执行失败，会返回一个非零的错误码

（1）初始化

//初始化条件变量

• int　 pthread_cond_init(pthread_cond_t　 * cond,pthread_condattr_t　 * cond_attr)

（2）等待

 //自动释放mutex锁，等待条件满足

• int　 pthread_cond_wait(pthread_cond_t　 * cond,pthread_mutex_t　 * mutex);

//自动释放 mutex 锁，等待条件满足，如果在 abstime 时间内还没有满足，则返回错误

• int　 pthread_cond_timewait(pthread_cond_t　 * cond,pthread_mutex　 * mutex,const　 timespec　 * abstime);

（3）销毁

//销毁条件变量

• int　 pthread_cond_destroy(pthread_cond_t　 * cond);　　

（4）唤醒

//让等待条件满足的线程中某一个被唤醒

• int　 pthread_cond_signal(pthread_cond_t　 * cond);

//让等待条件满足的线程中某一个被唤醒

• int　 pthread_cond_broadcast(pthread_cond_t　 * cond);

五、线程池

一个系统一般达到300线程是做合适的，超过300之后，性能反倒是降低，因此可以使用线程池

• 减少线程创建和销毁的开销：线程的创建和销毁是比较耗时的操作，若频繁进行，会浪费大量的系统资源和时间。线程池在初始化时创建一定数量的线程，这些线程可以被重复使用来执行不同的任务，避免了反复创建和销毁线程的开销，从而提高了系统的响应速度和性能。

• 提高资源利用率：线程池可以根据系统的负载情况动态调整线程的数量。当有大量任务提交时，线程池会增加线程数量来处理任务；当任务较少时，线程池会减少线程数量，避免资源的浪费。这样可以使系统资源得到更充分的利用，提高系统的整体性能。

• 提高响应速度：当有任务到达时，线程池中有空闲线程可以立即执行任务，而不需要等待线程的创建

（1）首先线程池需要一个任务队列，用来存放客户端发来的请求，

（2）两个链表，一个空闲链表（将初始化的线程全部放在里面）

（3）一个忙碌链表，存放正在干活的线程

（4）通过条件变量来控制进程等待还是唤醒

（5）通过互斥锁来避免高并发带来的同时修改同一数据问题

#include "ThreadPool2.h"

ThreadPool2::ThreadPool2(int num)
{
	this->min_num = num;
	pthread_mutex_init(&this->mutex, NULL);
	pthread_cond_init(&this->conn, NULL);
	for (int i = 0; i < this->min_num; i++)
	{
		pthread_t id = 0;
		pthread_create(&id, NULL, thread_handle, this);
		this->idle_list.push_back(id);
	}
}

ThreadPool2::~ThreadPool2()
{
}

void ThreadPool2::lock()
{
	pthread_mutex_lock(&this->mutex);
}

void ThreadPool2::unlock()
{
	pthread_mutex_unlock(&this->mutex);
}

void ThreadPool2::wait()
{
	pthread_cond_wait(&this->conn, &this->mutex);
}

//唤醒线程池
void ThreadPool2::wakeup()
{
	pthread_cond_signal(&this->conn);

}

//添加任务到队列
void ThreadPool2::add_task(BaseTask* task)
{
	this->task_queue.push(task);
	this->wakeup();
}

//从队列取出一个任务
BaseTask* ThreadPool2::remove_task()
{

	BaseTask* task = this->task_queue.front();
	this->task_queue.pop();

	return task;
}

//从空闲队列到忙碌队列
void ThreadPool2::idle_to_busy(pthread_t id)
{

	list<pthread_t>::iterator it;
	it = find(this->idle_list.begin(), this->idle_list.end(), id);
	if (it != this->idle_list.end())
	{
		this->idle_list.erase(it);//从空闲队列移除
		this->busy_list.push_back(id);//添加到忙碌队列中
	}

}

void ThreadPool2::busy_to_idle(pthread_t id)
{
	list<pthread_t>::iterator it;
	it = find(this->busy_list.begin(), this->busy_list.end(), id);
	if (it != this->busy_list.end())
	{
		this->busy_list.erase(it);
		this->idle_list.push_back(id);
	}
}

void* ThreadPool2::thread_handle(void* p)
{
	ThreadPool2* p_this = (ThreadPool2*)p;
	//获取当前线程id
	pthread_t id = pthread_self();

	//将当前线程与主线程脱离
	pthread_detach(id);

	while (1)
	{
		
		p_this->lock();
		if (p_this->task_queue.empty())
		{
			p_this->wait();
		}

		//将当前线程从空闲列表移动到忙碌列表
		p_this->idle_to_busy(id);
		//从任务队列中获取一个任务
		BaseTask* task = p_this->remove_task();
		p_this->unlock();
		//执行任务
		task->working();
		cout << "任务执行完毕" << endl;
		p_this->busy_to_idle(id);
	}

	return nullptr;
}