【ONE·Linux || 多线程（二）】
总言
多线程：生产者消费者模型与两种实现方式（条件变量、信号量）、线程池。
文章目录
- 总言
- 4、生产者消费者模型
-
- 4.1、基本概念
- 4.2、基于BlockingQueue的生产者消费者模型（理解条件变量）
-
- 4.2.1、单生产者单消费者模式（1.0）
-
- 4.2.1.1、阻塞队列 BlocQueue.hpp：充当交易场所
- 4.2.2.2、生产者消费者线程 ConProd.cc
- 4.2.2.3、演示结果与补充说明
- 4.2.2、多生产者多消费者模式（2.0）
-
- 4.2.2.1、引入任务派发 Task.hpp
- 4.2.2.2、加锁方式设计 lockGuard.hpp：PAII风格
- 4.2.2.3、整体
- 4.2.2.4、演示结果与补充说明
- 4.3、基于环形队列的生产消费模型
-
- 4.3.1、POSIX信号量介绍
- 4.3.2、结构需求和结构说明
- 4.3.3、单生产者单消费者模式（1.0）
-
- 4.3.3.1、环形队列 ringQueue.hpp：充当交易场所
- 4.3.3.2、信号量对象 Sem.hpp
- 4.3.3.3、生产者消费者线程 testMain.cc
- 4.3.3.4、演示结果
- 4.3.4、多生产者多消费者模式（2.0）
-
- 4.3.4.1、相关说明
- 4.3.4.2、整体演示
- 5、线程池
-
- 5.1、概念介绍
- 5.2、基本演示
-
- 5.2.1、thread.hpp
- 5.2.2、threadpool.hpp
- 5.2.3、testMain.cc
- 5.2.4、Task.hpp、log.hpp、lockGuard.hpp
4、生产者消费者模型
4.1、基本概念
说明： 生产者消费者模式就是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。这个阻塞队列就是用来给生产者和消费者解耦的。
PS：在下述编码实现过程中，始终要站在三种关系、两种角色、一个场所这类角色属性的角度来分析考虑，有助于理解代码操作。
4.2、基于BlockingQueue的生产者消费者模型（理解条件变量）
阻塞队列与普通的队列区别在于：
当队列为空时，从队列获取元素的操作将会被阻塞，直到队列中被放入了元素；
当队列为满时，往队列里存放元素的操作也会被阻塞，直到有元素被从队列中取出。
PS：以上空和满的操作是基于不同的线程来说的。
4.2.1、单生产者单消费者模式（1.0）
4.2.1.1、阻塞队列 BlocQueue.hpp：充当交易场所
框架搭建如下图：
具体实现如下：
#pragma once
#include
4.2.2.2、生产者消费者线程 ConProd.cc
#include "BlockQueue.hpp"
// 生产者线程：调用push接口，存入数据
void *Produce(void *args)
{
BlockQueue<int> *bqueue = (BlockQueue<int> *)args;
// 生产数据：
while (true)
{
int data = rand() % 100;
cout << "producer, 生产一个数据:" << data << endl;
bqueue->Push(data);
sleep(1);
}
return nullptr;
}
// 消费者线程：调用pop接口，取出数据
void *Consume(void *args)
{
BlockQueue<int> *bqueue = (BlockQueue<int> *)args;
// 消费数据：
while (true)
{
int data;
bqueue->Pop(&data);
cout << "consumer, 消费一个数据: " << data << endl;
sleep(1);
}
return nullptr;
}
int main()
{
//用于充当数据资源
srand((unsigned int)time(nullptr));
//创建交易场所：阻塞队列
BlockQueue<int>* bqueue = new BlockQueue<int>();
//创建两类线程：生产者、消费者
pthread_t ptor, cmer;
pthread_create(&ptor, nullptr, Produce, (void*)bqueue);//arg参数：传入阻塞队列，让两个线程能够看到同一个交易场所
pthread_create(&cmer, nullptr, Consume, (void*)bqueue);
//线程终止
pthread_join(ptor, nullptr);
pthread_join(ptor, nullptr);
delete bqueue;//注意释放空间
return 0;
}
4.2.2.3、演示结果与补充说明
演示结果：
1、可根据需求适当加入策略。如通过sleep控制生产消费双方线程速度，①生产慢、消费快；②生产快、消费慢；③生产消费速度同。等。
2、但无论上述哪一情况，阻塞队列实际不关心生产者消费者线程谁先运行或者谁在等待，因为在内部实现中已经考虑到执行流程。
对于生产者消费者模型，其效率优势体现在哪？
以上述单生产者单消费者为例，一定程度上缓解了生产者和消费者之间的数据处理能力。
对于多生产者多消费者，除了上述该点外，也有其它意义，后续说明。
4.2.2、多生产者多消费者模式（2.0）
4.2.2.1、引入任务派发 Task.hpp
#pragma once
#include
4.2.2.2、加锁方式设计 lockGuard.hpp：PAII风格
#pragma once
#include
4.2.2.3、整体
实则改动不大。
1、对BlockQueue.hpp，修改加锁风格，其余部分大体不变。
#pragma once
#include 2、对ConProd.cc，创建多线程（多个生产者、多个消费者，此部分内容在之前的环节中也有涉及），派发任务与接收任务（任务对象）。
#include "BlockQueue.hpp"
#include "Task.hpp"
int add(int x, int y)
{
return x+y;
}
// 生产者线程：调用push接口，存入数据
void *Produce(void *args)
{
BlockQueue<Task> *bqueue = (BlockQueue<Task> *)args;
// 派发任务：
while (true)
{
//生产前环节:获取一个任务
int x = rand() % 100;
usleep(1000);//主要是随机数由时间戳生成，这里延长些间隔时间
int y = rand() % 100;
Task assign(x, y, add);
//生产环节：生产者生产任务到阻塞队列
printf("%p---productor: (%d , %d )\n",pthread_self(), assign._x, assign._y);
bqueue->Push(assign);
sleep(2);
}
return nullptr;
}
// 消费者线程：调用pop接口，取出数据
void *Consume(void *args)
{
BlockQueue<Task> *bqueue = (BlockQueue<Task> *)args;
while (true)
{
//消费环节:消费者从阻塞队列中获取任务
Task assign;
bqueue->Pop(&assign);
//消费后环节：处理任务
printf("%p---consumer: addtion result is %d + %d = %d\n", pthread_self(), assign._x, assign._y, assign());
printf("\n");
sleep(2);
}
return nullptr;
}
int main()
{
//用于充当任务对象派发的数据资源
srand((unsigned int)time(nullptr));
//创建交易场所：阻塞队列
BlockQueue<Task>* bqueue = new BlockQueue<Task>();//向阻塞队列中存入的数据是Task任务对象
//创建两类线程：生产者、消费者
pthread_t ptor[2], cmer[2];
pthread_create(ptor, nullptr, Produce, (void*)bqueue);//arg参数：传入阻塞队列，让两个线程能够看到同一个交易场所
pthread_create(ptor+1, nullptr, Produce, (void*)bqueue);//arg参数：传入阻塞队列，让两个线程能够看到同一个交易场所
pthread_create(cmer, nullptr, Consume, (void*)bqueue);
pthread_create(cmer+1, nullptr, Consume, (void*)bqueue);
//线程终止
pthread_join(ptor[0], nullptr);
pthread_join(ptor[1], nullptr);
pthread_join(cmer[0], nullptr);
pthread_join(cmer[1], nullptr);
delete bqueue;//注意释放空间
return 0;
}
4.2.2.4、演示结果与补充说明
演示结果：
对多生产者多消费者意义的补充说明
至于使用单生产单消费还是多生产多消费，取决于具体场景中，接收任务和处理任务的耗时情况。假设这两环节在整体流程体系中所占据时间比例很小（即任务简单，都不太需要耗费时间），那么此时使用多生产多消费反而是一种累赘行为。
4.3、基于环形队列的生产消费模型
4.3.1、POSIX信号量介绍
1）、信号量介绍
1、什么是信号量？
POSIX信号量和SystemV信号量作用相同，都是用于同步操作，达到无冲突的访问共享资源目的。 但POSIX可以用于线程间同步。
信号量本质：是一个计数器，用于预定资源。访问临界资源的时候，必须先申请信号量资源(sem–，预订资源，P)，使用完毕信号量资源(sem++，释放资源V)
2、如何理解信号量的使用？
我们申请了一个信号量，当前执行流一定具有一个资源可以被使用。至于是哪一个资源，需要结合场景自定义编码完成。
2）、相关接口
PS：要理解信号量接口在生产者消费者模型中的使用，建议将相关接口的基本描述信息（DESCRIPTION）大致看一遍（man）。理解下述几个接口的含义。
初始化信号量：
NAME
sem_init - initialize an unnamed semaphore
SYNOPSIS
#include 销毁信号量：
NAME
sem_destroy - destroy an unnamed semaphore
SYNOPSIS
int sem_destroy(sem_t *sem);
等待信号量：
NAME
sem_wait, sem_timedwait, sem_trywait - lock a semaphore
SYNOPSIS
#include 发布信号量：
NAME
sem_post - unlock a semaphore
SYNOPSIS
#include
PV操作：是一种实现进程互斥与同步的有效方法，与信号量的处理相关。P表示通过的意思，V表示释放的意思。
PV操作是典型的同步机制之一。用一个信号量与一个消息联系起来，当信号量的值为0时，表示期望的消息尚未产生；当信号量的值非0时，表示期望的消息已经存在。用PV操作实现进程同步时，调用P操作测试消息是否到达，调用V操作发送消息。
4.3.2、结构需求和结构说明
4.3.3、单生产者单消费者模式（1.0）
4.3.3.1、环形队列 ringQueue.hpp：充当交易场所
#pragma once
#include
4.3.3.2、信号量对象 Sem.hpp
#ifndef _SEM_HPP_
#define _SEM_HPP_
#include
4.3.3.3、生产者消费者线程 testMain.cc
#include"ringQueue.hpp"
void* Produce(void* args)
{
ringQueue<int>* rq = (ringQueue<int>*)args;
while (true)
{
// 创建数据
int data = rand() % 100 +1 ;
// 生产者将数据存入交易场所中（环形队列）
rq->push(data);
printf("生产者: %d\n",data);
sleep(1);
}
}
void* Consume(void* args)
{
ringQueue<int>* rq = (ringQueue<int>*)args;
while(true)
{
// 消费者从交易场所取出数据并做后续处理
int data;
rq->pop(&data);
printf("消费者：%d\n", data);
sleep(1);
}
}
int main()
{
//用随机数模拟数据
srand((unsigned int)time(nullptr));
//创建交易场所：环形队列
ringQueue<int>* rq = new ringQueue<int>();
//创建并初始化生产者、消费者线程
pthread_t ptor, cmer;
pthread_create(&ptor, nullptr, Produce, (void*)rq);
pthread_create(&cmer, nullptr, Consume, (void*)rq);
//线程捕获
pthread_join(ptor,nullptr);
pthread_join(cmer,nullptr);
delete rq;
return 0;
}
4.3.3.4、演示结果
演示结果：对于数据输出部分可以根据需求调整修改。
4.3.4、多生产者多消费者模式（2.0）
4.3.4.1、相关说明
4.3.4.2、整体演示
对testMain.cc：多增了线程创建和线程终止。
#include"ringQueue.hpp"
void* Produce(void* args)
{
ringQueue<int>* rq = (ringQueue<int>*)args;
while (true)
{
// 创建数据
int data = rand() % 100 +1 ;
// 生产者将数据存入交易场所中（环形队列）
rq->push(data);
printf("生产者--%p: %d\n",pthread_self(),data);
sleep(1);
}
}
void* Consume(void* args)
{
ringQueue<int>* rq = (ringQueue<int>*)args;
while(true)
{
// 消费者从交易场所取出数据并做后续处理
int data;
rq->pop(&data);
printf("消费者--%p: %d\n", pthread_self(),data);
sleep(1);
}
}
int main()
{
//用随机数模拟数据
srand((unsigned int)time(nullptr)^getpid());
//创建交易场所：环形队列
ringQueue<int>* rq = new ringQueue<int>();
//创建并初始化生产者、消费者线程
pthread_t ptor[2], cmer[2];
pthread_create(ptor, nullptr, Produce, (void*)rq);
pthread_create(ptor+1, nullptr, Produce, (void*)rq);
pthread_create(cmer, nullptr, Consume, (void*)rq);
pthread_create(cmer+1, nullptr, Consume, (void*)rq);
//线程捕获
pthread_join(ptor[0],nullptr);
pthread_join(ptor[1],nullptr);
pthread_join(cmer[0],nullptr);
pthread_join(cmer[1],nullptr);
delete rq;
return 0;
}
对ringQueue.hpp：在环形队列中分别为生产者消费者创建了各自的锁，使用于push、pop接口。
#pragma once
#include
演示结果：还可以将其修改为派发任务的情况。
5、线程池
5.1、概念介绍
线程池:
一种线程使用模式。线程过多会带来调度开销，进而影响缓存局部性和整体性能，而线程池维护着多个线程，等待着监督管理者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代价，线程池不仅能够保证内核的充分利用，还能防止过分调度。可用线程数量应该取决于可用的并发处理器、处理器内核、内存、网络sockets等的数量。
线程池的应用场景：
1、需要大量的线程来完成任务，且完成任务的时间比较短。 WEB服务器完成网页请求这样的任务，使用线程池技术是非常合适的。因为单个任务小，而任务数量巨大，你可以想象一个热门网站的点击次数。 但对于长时间的任务，比如一个Telnet连接请求，线程池的优点就不明显了。因为Telnet会话时间比线程的创建时间大多了。
2、对性能要求苛刻的应用，比如要求服务器迅速响应客户请求。
3、接受突发性的大量请求，但不至于使服务器因此产生大量线程的应用。突发性大量客户请求，在没有线程池情况下，将产生大量线程，虽然理论上大部分操作系统线程数目最大值不是问题，短时间内产生大量线程可能使内存到达极限，出现错误。
5.2、基本演示
PS：以下只是最基本的演示案例，可根据需求继续修改、完善、补充。
5.2.1、thread.hpp
#pragma once
#include
5.2.2、threadpool.hpp
#pragma once
#include
5.2.3、testMain.cc
#include
5.2.4、Task.hpp、log.hpp、lockGuard.hpp
Task.hpp
#pragma once
#include
log.hpp
#pragma once
#include
lockGuard.hpp
#pragma once
#include
其它：待补充。