c++游戏小技巧14:多线程+线程池（全网最全,c++）

已于 2024-04-11 14:20:09 修改
阅读量1.3k 收藏 22
点赞数 28
分类专栏： 游戏小技巧 文章标签： c++ 小技巧 游戏
于 2024-01-23 17:29:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_57427186/article/details/135774956
版权

1.前言

最近，被期末考试AK的zzb在回顾以前的代码时，无意看到一个问题:

请问:

大佬能解释一下怎么同时运行两个c++for循环吗？
就比如说游戏里你一边出招电脑也能出招这种的

 当时，zzb是用的kd来解决(详见小技巧2)

而现在，zzb要用一种新的方式:

多线程

2.正文

1.定义

摘自百度百科

多线程（multithreading），是指从软件或者硬件上实现多个线程并发执行的技术。具有多线程能力的计算机因有硬件支持而能够在同一时间执行多于一个线程，进而提升整体处理性能。具有这种能力的系统包括对称多处理机、多核心处理器以及芯片级多处理或同时多线程处理器。在一个程序中，这些独立运行的程序片段叫作“线程”（Thread），利用它编程的概念就叫作“多线程处理” 

所以，上述问题用c++就可以很好解决

2.thread

1.定义

thread是c++多线程中的一种

在c++11时，头文件

#include<thread>

就被加入

该头文件中定义了thread类，创建一个线程即实例化一个该类的对象，实例化对象时候调用的构造函数需要传递一个参数，该参数就是函数名，thread th1(proc1)；如果传递进去的函数本身需要传递参数，实例化对象时将这些参数按序写到函数名后面，thread th1(proc1,a,b);只要创建了线程对象（传递“函数名/可调用对象”作为参数的情况下），线程就开始执行（std::thread 有一个无参构造函数重载的版本，不会创建底层的线程）。

看着很绕对不对？

用样例解释一下

#include<iostream>
#include<thread>
using namespace std;

void zzb(int a){cout<<"这是线程"<<a<<"\n";}

int main()
{
    cout<<"主线程:"<<endl;
    //定义 线程名 函数名 参数 
    thread th2     (zzb,   9);
    cout<<"主线程中显示子线程id为"<<th2.get_id()<<endl;//获取线程id 
    th2.join();//暂停主线程，运行th2 
    return 0;
}

运行出来的效果可能是

‘

当然，也可能是

甚至种种

(大致是因为线程运行的时间不定吧)

在网上看到一个生动的例子：

你在做某件事情，中途你让老王帮你办一个任务（你办的时候他同时办）（创建线程1），又叫老李帮你办一件任务（创建线程2），现在你的这部分工作做完了，需要用到他们的结果，只需要等待老王和老李处理完（join()，阻塞主线程），等他们把任务做完（子线程运行结束），你又可以开始你手头的工作了（主线程不再阻塞）。

而代码里面也用到了一些成员函数:

2.成员函数

函数名作用
get_id获取线程 ID
joinable(bool)检查线程是否可被 join，如果线程未被join或detach则返回true
join阻塞(暂停)当前线程直到join的线程返回
detach不阻塞当前线程，不等待该线程返回，相当于这是个守护线程。
swap交换线程
native_handlee,点这里
hardware_concurrencye,检测硬件并发特性（后两个zzb都不会awa）

3.创建线程

1里面是直接创建，再来一遍加深记忆

#include<iostream>
#include<thread>
using namespace std;

void zzb(int a){cout<<"\n这是线程"<<a<<"\n";}

int main()
{
    cout<<"主线程:"<<endl;
    //定义 线程名 函数名 参数 
    thread th2     (zzb,   9);
    cout<<"主线程中显示子线程id为"<<th2.get_id()<<endl;//获取线程id 
    th2.join();//暂停主线程，运行th2 
    return 0;
}

除此之外，匿名函数lambda也可以

#include<iostream>
#include<thread>
using namespace std;

int main()
{
	auto zzb=[](int a){cout<<"这是线程"<<a<<"\n";};
	//定义 线程名 函数名 参数 
    thread th2     (zzb,   9);
	th2.join();
	return 0;
}

class也可以

#include<iostream>
#include<thread>
using namespace std;

class node
{
	public:
		void zzb(int a){cout<<"这是线程"<<a<<"\n";}
}a;

int main()
{
    thread th2(&node::zzb,&a,9);
	th2.join();
	return 0;
}

4.互斥量

1里面出现了一个神奇的bug

而对于这个bug，互斥量就可以解决

比方:

这样比喻，单位上有一台打印机（共享数据a），你要用打印机（线程1要操作数据a），同事老王也要用打印机(线程2也要操作数据a)，但是打印机同一时间只能给一个人用，此时，规定不管是谁，在用打印机之前都要向领导申请许可证（lock），用完后再向领导归还许可证(unlock)，许可证总共只有一个,没有许可证的人就等着在用打印机的同事用完后才能申请许可证(阻塞，线程1lock互斥量后其他线程就无法lock,只能等线程1unlock后，其他线程才能lock)，那么，这个许可证就是互斥量。互斥量保证了使用打印机这一过程不被打断。

互斥量在

#include<mutex>

 里面

用法：

#include<iostream>
#include<thread>
#include<mutex>
using namespace std;

mutex m;//实例化m对象，不要理解为定义变量

void p1(int a)
{
    m.lock();//许可
    cout<<"p1函数正在改写a"<<endl;
    cout<<"原始a为"<<a<<endl;
    cout<<"现在a为"<<a+2<<endl;
    m.unlock();//归还，一定要写，不然TLE
}

void p2(int a)
{
    m.lock();
    cout<<"p2函数正在改写a"<<endl;
    cout<<"原始a为"<<a<<endl;
    cout<<"现在a为"<<a+1<<endl;
    m.unlock();
}

void p3(int a)
{
    cout<<"p3函数正在改写a"<<endl;
    cout<<"原始a为"<<a<<endl;
    cout<<"现在a为"<<a+2<<endl;
}

void p4(int a)
{
    cout<<"p4函数正在改写a"<<endl;
    cout<<"原始a为"<<a<<endl;
    cout<<"现在a为"<<a+1<<endl;
}

int main()
{
    int a=0;
    thread pr1(p1,a);
    thread pr2(p2,a);
    pr1.join();
    pr2.join();
    system("pause");
    thread pr3(p3,a);
    thread pr4(p4,a);
    pr3.join();
    pr4.join();
    return 0;
}

效果很明显:

前面很合理，后面很核理

再详细说一下互斥量函数

5.mutex

1.lock

调用线程将锁住该互斥量。线程调用该函数会发生下面 3 种情况：

1.如果该互斥量当前没有被锁住，则调用线程将该互斥量锁住，直到调用 unlock之前，该线程一直拥有该锁。

2.如果当前互斥量被其他线程锁住，则当前的调用线程被阻塞住。

3.如果当前互斥量被当前调用线程锁住，则会产生死锁(deadlock)(说白了TLE)。

2.unlock()

解锁，释放对互斥量的所有权，如果没有锁的所有权尝试解锁会导致程序异常。

3 try_lock()

尝试锁住互斥量，如果互斥量被其他线程占有，则当前线程也不会被阻塞。线程调用该函数也会出现下面 3 种情况：

1.如果当前互斥量没有被其他线程占有，则该线程锁住互斥量，直到该线程调用 unlock 释放互斥量。
2.如果当前互斥量被其他线程锁住，则当前调用线程返回 false，而并不会被阻塞掉。
3.如果当前互斥量被当前调用线程锁住，则会产生死锁(deadlock)。

4.lock_guard()

e，一个局部对象，对象内自动+-lock

例子:

#include<iostream>
#include<thread>
#include<mutex>
using namespace std;

mutex m;//实例化m对象，不要理解为定义变量

void p1(int a)
{
    lock_guard<mutex> g1(m);//用此语句替换了m.lock()；
	//lock_guard传入一个参数时，该参数为互斥量，此时调用了lock_guard的构造函数，申请锁定m
    cout<<"p1函数正在改写a"<<endl;
    cout<<"原始a为"<<a<<endl;
    cout<<"现在a为"<<a+2<<endl;
}//此时不需要写m.unlock(),g1出了作用域被释放，自动调用析构函数，于是m被解锁

void p2(int a)
{
    {
        lock_guard<mutex> g2(m);
        cout<<"p2函数正在改写a"<<endl;
        cout<<"原始a为"<<a<<endl;
        cout<<"现在a为"<<a+1<<endl;
    }//通过使用{}来调整作用域范围，可使得m在合适的地方被解锁
    cout<<"作用域外的内容3"<<endl;
    cout<<"作用域外的内容4"<<endl;
    cout<<"作用域外的内容5"<<endl;
}

int main()
{
    int a=0;
    thread pr1(p1,a);
    thread pr2(p2,a);
    pr1.join();
    pr2.join();
    return 0;
}

当然,lock_guard传两个参数时，如果第二个为adopt_lock标识时，表示不再构造函数中不再进行互斥量锁定，因此此时需要提前手动锁定。（不然位置还是要乱）

#include<iostream>
#include<thread>
#include<mutex>
using namespace std;

mutex m;//实例化m对象，不要理解为定义变量

void p1(int a)
{
	m.lock(); 
    lock_guard<mutex> g1(m,adopt_lock);//用此语句替换了m.lock()；
	//lock_guard传入一个参数时，该参数为互斥量，此时调用了lock_guard的构造函数，申请锁定m
    cout<<"p1函数正在改写a"<<endl;
    cout<<"原始a为"<<a<<endl;
    cout<<"现在a为"<<a+2<<endl;
}//此时不需要写m.unlock(),g1出了作用域被释放，自动调用析构函数，于是m被解锁

void p2(int a)
{
    {
        lock_guard<mutex> g2(m);
        cout<<"p2函数正在改写a"<<endl;
        cout<<"原始a为"<<a<<endl;
        cout<<"现在a为"<<a+1<<endl;
    }//通过使用{}来调整作用域范围，可使得m在合适的地方被解锁
    cout<<"作用域外的内容3"<<endl;
    cout<<"作用域外的内容4"<<endl;
    cout<<"作用域外的内容5"<<endl;
}

int main()
{
    int a=0;
    thread pr1(p1,a);
    thread pr2(p2,a);
    pr1.join();
    pr2.join();
    return 0;
}

当然,比起lock_guard，unique_lock更强

除了adopt_lock，它还支持try_to_lock/defer_lock

别的一样(所以谁还用lock_guard?)

try_to_lock: 尝试去锁定，得保证锁处于unlock的状态,然后尝试现在能不能获得锁；尝试用mutx的lock()去锁定这个mutex，但如果没有锁定成功，会立即返回，不会阻塞在那里
defer_lock: 始化了一个没有加锁的mutex;

例子:

#include<iostream>
#include<thread>
#include<mutex>
using namespace std;

mutex m;
void p1(int a)
{
    unique_lock<mutex> g1(m,defer_lock);//始化了一个**没有加锁**的mutex
    cout<<"关注一下吧"<<endl;
    g1.lock();//手动加锁;
	//注意，不是m.lock();
	//注意，不是m.lock();
	//注意，不是m.lock()
    cout<<"proc1函数正在改写a"<<endl;
    cout<<"原始a为"<<a<<endl;
    cout<<"现在a为"<<a+2<<endl;
    g1.unlock();//临时解锁
    cout<<"祝关注的同学"<<endl;
    g1.lock();
    cout<<"AKIOI，暴打集训队"<<endl;
}//自动解锁

void p2(int a)
{
    unique_lock<mutex> g2(m,try_to_lock);//尝试加锁，但如果没有锁定成功，会立即返回，不会阻塞在那里；
    cout<<"proc2函数正在改写a" << endl;
    cout<<"原始a为"<<a<<endl;
    cout<<"现在a为"<<a+1<<endl;
}//自动解锁

int main()
{
    int a=0;
    thread pr1(p1,a);
    thread pr2(p2,a);
    pr1.join();
    pr2.join();
    return 0;
}

（还是会错位，可能因为临时解锁时可能正好try_to_lock try到了）

繁琐是很繁琐，但用的时候还是真香

recursive_mutex

允许同一个线程对互斥量多次上锁（即递归上锁），来获得对互斥量对象的多层所有权

放互斥量时需要调用与该锁层次深度相同次数的 unlock()，可理解为 lock() 次数和 unlock() 次数相同

其余=mutex

time_mutex

比mutex多了两个函数

try_lock_for 函数接受一个时间范围，表示在这一段时间范围之内线程如果没有获得锁则被阻塞住（与 std::mutex 的 try_lock() 不同，try_lock 如果被调用时没有获得锁则直接返回 false），如果在此期间其他线程释放了锁，则该线程可以获得对互斥量的锁，如果超时（即在指定时间内还是没有获得锁），则返回 false。

try_lock_until 函数则接受一个时间点作为参数，在指定时间点未到来之前线程如果没有获得锁则被阻塞住，如果在此期间其他线程释放了锁，则该线程可以获得对互斥量的锁，如果超时（即在指定时间内还是没有获得锁），则返回 false。

#include<iostream>
#include<chrono>
#include<thread>
#include<mutex>
using namespace std;

timed_mutex m;

void p1()
{
	//等lock: 每随机ms输出一次关注(还不关注) 
	while(!m.try_lock_for(std::chrono::milliseconds(rand()%200+1))) cout<<"关注";
	//得到lock,等1s后输出点赞(还不点赞)
	this_thread::sleep_for(std::chrono::milliseconds(1000));
	cout<<"点赞\n";
	m.unlock();
}

int main()
{
	srand(time(NULL));
	std::thread t[5];//线程组
	for(int i=0;i<5;i++)t[i]=thread(p1);
	for(auto& th:t)th.join();
	return 0;
}

recursive_timed_mutex

e，你看一下recursive_mutex与mutex的区别，再类比一下(不会问老师什么是类比)

6.condition_variable

e，scratch中的广播用过吧？

比如:

你正在买东西，发现脏脏包卖完了，然后你联系服务员(join)，如果你收到服务员的@(收到广播)再接着买

例子:        

#include<stdio.h>
#include<stdlib.h>
#include<iostream>
#include<thread>
#include<mutex>
#include<bits/stdc++.h>
using namespace std;

int a=0;
mutex m;
condition_variable cond;

void th1()
{
	unique_lock<mutex> lock(m);//自动上锁，解放双手 
	cond.wait(lock,[]{return!(a%1000);});//回应 
	++a;
}

void th2()
{
	for(int i=0;i<100000;++i)
	{
		unique_lock<std::mutex> lock(m);
		if(!(a%1000)) cond.notify_one();//回应 
		++a;
	}
}

int main()
{
	thread t1(th1);
	thread t2(th2);
	t1.join();
	t2.join();
	cout<<a<<endl;
	return 0;
}

同样，相互呼应像不像:

（你在存钱，某条dog在取钱）

#include<iostream>
#include<deque>
#include<thread>
#include<mutex>
#include<condition_variable>
#include<windows.h>
using namespace std;

deque<int> q;
mutex m;
condition_variable cond;
int c=0;//缓冲区的钱个数 

void p()
{ 
	int d;
	while(1)
	{
		//通过外层循环，能保证生成用不停止
		if(c<3)
		{//限流
			{
				d=rand();
				unique_lock<mutex> locker(m);//锁
				q.push_front(d);
				cout<<"存了"<<d<<"元"<<endl;
				cond.notify_one();//通知取
				++c;
			}
			Sleep(500);
		}
	}
}

void co()
{
	int d;
	while(1)
	{
		{
			unique_lock<mutex> locker(m);
			while(q.empty()) cond.wait(locker); //wati()阻塞前先会解锁,解锁后生产者才能获得锁来放产品到缓冲区；生产者notify后，将不再阻塞，且自动又获得了锁。
			d=q.back();//取的第一步
			q.pop_back();//取的第二步
			cout<<"取了"<<d<<"元"<<endl;
			--c;
		}
		Sleep(1500);
	}
}

int main()
{
	thread t1(p);
	thread t2(co);
	t1.join();
	t2.join();
	return 0;
}

然后你就可以发现:

其实不存钱最好

7.原子类型

终于到了最后一个了

先问一个问题:
Q:mutex是上锁对吧？那么能递归不断上锁解锁的是什么？

A：recursive_mutex

Q:time_mutex多了那些函数？

 try_lock_for与try_lock_until

OK，来看最后亿个：

原子类型

首先，了解一下:

原子类型=简单数据结构(int,bool,char)+(保护无限+耐久无限)下界合金甲

用人话说:就是它打不断(不能强制停止)，切不了(不能swap)

而且，它不需要上锁

可惜的是，它只能++、--、+=、-=

#include<stdio.h>
#include<stdlib.h>
#include<iostream>
#include<thread>
#include<atomic>//原子
using namespace std;

atomic<int> a;
//int a=0;//你可以试一下，与期望答案不一样oh 

void th1()
{
	for(int i=0;i<100000;i++) ++a;
}

void th2()
{
	for(int i=0;i<100000;i++) ++a;
}

int main()
{
	thread t1(th1);
	thread t2(th2);
	t1.join();
	t2.join();
	cout<<a<<endl;
	return 0;
}

所以说，如果变量在线程里要改变的话，atomic YYDS!!!

3.async

1.async

async是thread的高级封装

封装了thread promise与packaged_task

基本可以替代thread

只是它是异步任务

所以thread有什么用？？？

#include<iostream>
#include<thread>
#include<mutex>
#include<future>
using namespace std;

int th()
{
	this_thread::sleep_for(chrono::milliseconds(1000));
	cout<<"thread_task"<<endl;
	return 0;
}

int main()
{
	async(th);
	return 0;
}

2.future

async异步任务可以返回一个future对象，可用来保存子线程入口函数的返回值。
async、std::packaged_task 或 promise都能提供一个future对象给该异步操作的创建者。

#include<iostream>
#include<thread>
#include<mutex>
#include<future>
using namespace std;

int thread_task()
{
	this_thread::sleep_for(chrono::milliseconds(1000));
	cout<<"thread_task"<<endl;
	return 0;
}

int main()
{
	future<int> res=async(thread_task);
	cout<<res.get()<<"\n";
//	while(1) res.get();//不要多次执行get,否则你可以逝世 
	return 0;
}

3.packaged_task

没看懂网上的解释

大致是把自己的调用对象的运行成果传给future

在网上抄了一段:

std::packaged_task 包装一个可调用的对象，并且允许异步获取该可调用对象产生的结果，从包装可调用对象意义上来讲，std::packaged_task 与 std::function 类似，只不过 std::packaged_task 将其包装的可调用对象的执行结果传递给一个 std::future 对象（该对象通常在另外一个线程中获取 std::packaged_task 任务的执行结果）。
std::packaged_task 对象内部包含了两个最基本元素：一、被包装的任务(stored task)，任务(task)是一个可调用的对象，如函数指针、成员函数指针或者函数对象；二、共享状态(shared state)，用于保存任务的返回值，可以通过 std::future 对象来达到异步访问共享状态的效果。

代码例子也是C的

#include <stdio.h>
#include <stdlib.h>

#include <iostream> // std::cout
#include <thread>   // std::thread
#include <mutex>    // std::mutex
#include <future>	// std::future

int thread_task(int i)
{
	std::this_thread::sleep_for(std::chrono::milliseconds(1000));
	std::cout << "thread_task" << i << std::endl;
	return 0;
}

int main()
{
	std::packaged_task<int(int)> pack(thread_task);
	std::thread mythread(std::ref(pack), 5);
	mythread.join();
	std::future<int> result = pack.get_future();
	std::cout << result.get() << std::endl;
	return 0;
}

4.promise

在一个线程里对某个对象赋值，然后在别的进程里提出来

#include<bits/stdc++.h>
using namespace std;

int th(promise<int>&p, int i)
{
	this_thread::sleep_for(chrono::milliseconds(1000));
	cout<<"线程:"<<i<<endl;
	p.set_value(i);//只能用一次，不然参考while(1)get() 
	return 0;
}

int main()
{
	promise<int> p;
	thread t(th,ref(p),5);
	t.join();
	future<int> r=p.get_future();
	cout<<r.get()<<endl;//好像说过了，也只能用一次，不然参考while(1)set_value 
	return 0;
}

OK,关于线程的主要部分就讲完了！！！

4.拓展:线程池

不采用线程池时：

创建线程 -> 由该线程执行任务 -> 任务执行完毕后销毁线程。即使需要使用到大量线程，每个线程都要按照这个流程来创建、执行与销毁。

虽然创建与销毁线程消耗的时间 远小于 线程执行的时间，但是对于需要频繁创建大量线程的任务，创建与销毁线程 所占用的时间与CPU资源也会有很大占比。

为了减少创建与销毁线程所带来的时间消耗与资源消耗，因此采用线程池的策略：

程序启动后，预先创建一定数量的线程放入空闲队列中，这些线程都是处于阻塞状态，基本不消耗CPU，只占用较小的内存空间。

接收到任务后，线程池选择一个空闲线程来执行此任务。

任务执行完毕后，不销毁线程，线程继续保持在池中等待下一次的任务。

线程池所解决的问题：

(1) 需要频繁创建与销毁大量线程的情况下，减少了创建与销毁线程带来的时间开销和CPU资源占用。（省时省力）

(2) 实时性要求较高的情况下，由于大量线程预先就创建好了，接到任务就能马上从线程池中调用线程来处理任务，略过了创建线程这一步骤，提高了实时性。（实时）

代码:（解释下次更）

#include<bits/stdc++.h>
#include<windows.h>
using namespace std;

namespace ThreadPool
{
	#define MAX 100//维护线程数量，使其在可控范围内 
	typedef struct task{void(*function)(void*A);void*A;}task;//任务
	struct Td//线程池结构体(任务队列)
	{
	    task* taskQ;
	    int qmax,tsize,h,t;//容量,任务个数,队头,队尾
	    pthread_t mID;//管理者ID
	    pthread_t *uID;//工作线程ID
	    int Min,Max,Use,cuse,nuse;//最小线程数量,最大线程数量,正在使用(use),可以使用(can use),不可使用(can't use) 
	    pthread_mutex_t lk,ulk;//锁整个的线程池,锁Use变量
	    pthread_cond_t F,E;//任务队列是不是满了,任务队列是不是空了
		bool die;//销毁线程池?1:0
	};
	typedef struct Td Td;
	Td *build(int a,int b,int sz);//创建线程池
	int killtd(Td*nx);//销毁线程池
	void td_add(Td*nx,void(*func)(void*),void*A);//添加任务
	int get_b(Td*nx);//获取线程池中工作线程的个数
	int get_c(Td*nx);//获取线程池中可使用的线程的个数
	void*do_task(void*a);//做工作 
	void*control(void*a);//管理线程 
	void exit(Td*nx);//单个线程退出
	Td* build(int a,int b,int sz)
	{
		Td*nx=(Td*)malloc(sizeof(Td));
		do
		{
			if(nx==NULL){printf("线程创立失败...\n");break;}
			nx->uID=(pthread_t*)malloc(sizeof(pthread_t)*b);
			if(nx->uID==NULL){printf("使用线程id创立失败...\n");break;}
			memset(nx->uID,0,sizeof(pthread_t)*b);
			nx->Min=a;nx->Max=b;nx->Use=0;nx->cuse=a;nx->nuse=0;
			if(pthread_mutex_init(&nx->lk,NULL)!=0||pthread_mutex_init(&nx->ulk,NULL)!=0||
				pthread_cond_init(&nx->E,NULL)!=0||pthread_cond_init(&nx->F,NULL)!=0){printf("条件初始化失败...\n");break;}
			nx->taskQ=(task*)malloc(sizeof(task)*sz);
			nx->qmax=sz;
			nx->tsize=nx->h=nx->t =nx->die=0;
			pthread_create(&nx->mID,NULL,control,nx);//创建线程
			for(int i=0;i<a;++i) pthread_create(&nx->uID[i],NULL,do_task,nx);
			return nx;
		}while(0);
		if(nx&&nx->uID) free(nx->uID);//释放
		if(nx&&nx->taskQ) free(nx->taskQ);
		if(nx) free(nx);
		return NULL;
	}
	int killtd(Td*nx)
	{
		if(nx==NULL) return -1;
		nx->die=1;//关闭线程池
		pthread_join(nx->mID,NULL);//阻塞回收管理者线程
		for(int i=0;i<nx->cuse;++i) pthread_cond_signal(&nx->E);//解开阻塞的消费者线程
		if(nx->taskQ) free(nx->taskQ);//释放
		if(nx->uID) free(nx->uID);
		pthread_mutex_destroy(&nx->lk);pthread_mutex_destroy(&nx->ulk);
		pthread_cond_destroy(&nx->E);pthread_cond_destroy(&nx->F);
		free(nx);nx=NULL;
		return 0;
	}
	void td_add(Td*nx,void(*func)(void*),void*a)
	{
		pthread_mutex_lock(&nx->lk);
		while(nx->tsize==nx->qmax&&!nx->die) pthread_cond_wait(&nx->F,&nx->lk);//阻塞生产者线程
		if(nx->die){pthread_mutex_unlock(&nx->lk);return;}
		nx->taskQ[nx->t].function=func;nx->taskQ[nx->t].A=a;nx->t=(nx->t+1)%nx->qmax;nx->tsize++;//添加任务
		pthread_cond_signal(&nx->E);
		pthread_mutex_unlock(&nx->lk);
	}
	int get_b(Td*nx)
	{
		pthread_mutex_lock(&nx->ulk);
		int u=nx->Use;
		pthread_mutex_unlock(&nx->ulk);
		return u;
	}
	int get_c(Td*nx)
	{
		pthread_mutex_lock(&nx->lk);
		int c=nx->cuse;
		pthread_mutex_unlock(&nx->lk);
		return c;
	}
	void*do_task(void* a)
	{
		Td*nx=(Td*)a;
		while(1)
		{
			pthread_mutex_lock(&nx->lk);
			while(nx->tsize==0&&!nx->die)//当前任务队列是否为空
			{
				pthread_cond_wait(&nx->E,&nx->lk);//阻塞工作线程
				if(nx->nuse>0)//判断是不是要销毁线程
				{
					nx->nuse--;
					if(nx->cuse>nx->Min)nx->cuse--,pthread_mutex_unlock(&nx->lk),exit(nx);
				}
			}
			if(nx->die) pthread_mutex_unlock(&nx->lk),exit(nx);//判断线程池是否被关闭了
			task t;//取出任务
			t.function=nx->taskQ[nx->h].function,t.A=nx->taskQ[nx->h].A;
			nx->h=(nx->h+1)%nx->qmax;//移动头指针 
			nx->tsize--;
			pthread_cond_signal(&nx->F),pthread_mutex_unlock(&nx->lk);//解锁
			printf("线程%lld运行中...\n", pthread_self());//输出 
			pthread_mutex_lock(&nx->ulk);
			nx->Use++;
			pthread_mutex_unlock(&nx->ulk);
			t.function(t.A);
			free(t.A);//释放
			t.A=NULL; 
			printf("线程%lld完成任务...\n", pthread_self());
			pthread_mutex_lock(&nx->ulk);
			nx->Use--;
			pthread_mutex_unlock(&nx->ulk);
		}
		return NULL;
	}
	void*control(void*a)
	{
		Td*nx=(Td*)a;
		while(!nx->die)
		{
			Sleep(3000);//3s检查一次
			pthread_mutex_lock(&nx->lk);//取出线程池中任务的数量和当前线程的数量
			int sz=nx->tsize;
			int cu=nx->cuse;
			pthread_mutex_unlock(&nx->lk);
			int Use=get_b(nx);//取出正在的线程的数量
			//添加线程(任务的个数>存活的线程个数&&存活的线程数<最大线程数)
			if(sz>cu&&cu<nx->Max)
			{
				pthread_mutex_lock(&nx->lk);
				int c=0;
				for(int i=0;i<nx->Max&&c<MAX&&nx->cuse<nx->Max;++i)
					if(nx->uID[i]==0) pthread_create(&nx->uID[i], NULL,do_task,nx),c++,nx->cuse++;
				pthread_mutex_unlock(&nx->lk);
			}
			//销毁线程(正在的线程*2<存活的线程数 && 存活的线程>最小线程数)
			if(Use*2<cu&&cu>nx->Min)
			{
				pthread_mutex_lock(&nx->lk);
				nx->nuse=MAX;
				pthread_mutex_unlock(&nx->lk);
				for(int i=0;i<MAX;++i) pthread_cond_signal(&nx->E);
			}
		}
		return NULL;
	}
	void exit(Td*nx)
	{
		pthread_t id=pthread_self();
		for(int i=0;i<nx->Max;++i)
			if(nx->uID[i]==id){nx->uID[i]=0;printf("线程%lld正在退出...\n",id);break;}
		pthread_exit(NULL);
	}
	void taskFunc(void*A)//函数内执行的任务 
	{
	    int b=*(int*)A;
	    Sleep(1000);
	    printf("线程%lld正在工作，num值为%d\n",pthread_self(),b);
	}
}
using namespace ThreadPool;

int main()
{
	Td*a=build(3,100,100);
	for(int i=0;i<1000;++i)
	{
		int*b=(int*)malloc(sizeof(int));
		*b=i+100;
		td_add(a,taskFunc,b);
	}
	Sleep(3000);
	killtd(a);
    return 0;
}

5.后文

zzb考完了，最近会不断更新文章

挖的坑也会不上，别急

上一篇:c++游戏小技巧13:中文输出(编码转汉字)_c++输出汉字-CSDN博客

下一篇:c++游戏小技巧15：前14篇总结​​​​​​​

C/C++编译器并行优化技术：并行优化针对多核处理器和多线程环境进行优化，以提高程序的并行度
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
04-19 3830
C-C++编译器并行优化技术：并行优化针对多核处理器和多线程环境进行优化，以提高程序的并行度
线程池(C/C++版)
02-16
C/C++ threadpool封装, 线程池, Linux, 多线程, pthread
c++ 实现线程池的使用
10-15
本文介绍的线程池采用C++语言，在windows平台下实现。 适用场合：    1.需要大量的线程来完成任务，且完成任务的时间比较短。    2.对性能要求苛刻的应用，比如要求服务器迅速相应客户请求。    3.接受突发性的大量请求，但不至于使服务器因此产生大量线程的应用。
C++多线程以及线程池
梦的灰色边沿...
06-10 5324
1 线程 1.1 简介   线程（英语：thread）是操作系统能够进行运算调度的最小单位。大部分情况下，它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。在Unix System V及SunOS中也被称为轻量进程（lightweight processes），但轻量进程更多指内核线程（kernel thread），而把用户线程（user thread）称为线程。   同一进程中的多条线程将共享该进程中的全部系统资源
c++小游戏（附源码）
bbc121223的博客
07-24 4691
if(j==3) cout<<"你使用了太极神功（盗版）"<<endl<<"========================================="<<endl<<"lose！if(j==4) cout<<"你变身成了盖亚"<<endl<<"========================================="<<endl<<"lose！cout<<"选择狒狒"<<endl<<"=========================================="<<endl;
C++ 线程池
暮色尽染的博客
07-01 1734
(来自ChatGPT)线程池是一种用于管理和复用线程的机制。它可以提高程序的性能和效率，特别是在处理大量并发任务时。线程池中包含一定数量的线程，这些线程可以重复执行多个任务。当有任务需要执行时，可以将任务提交给线程池，线程池会选择一个可用的线程来执行任务。任务执行完毕后，线程会返回线程池，等待下一个任务的到来。线程池的优点：降低线程创建和销毁的开销：线程的创建和销毁是比较耗费资源的操作，使用线程池可以避免频繁地创建和销毁线程，提高程序的性能。提高系统的响应速度。
使用C++实现线程池
JunJie的个人博客
04-16 722
使用C++的函数对象封装具体的任务，使用线程池来异步执行这些任务。线程池中实现了任务队列和线程池组，每个线程检测任务队列中有任务，就会执行，执行完毕继续等待新任务的到来。
多线程游戏
哈哈哈哈哈哈哈哈的博客
05-20 1599
1.程序、进程、线程 ①程序 存在硬盘里面的文件，固定文件，包含（代码，素材，配置文件……） ②进程 一个程序从载入内存，进程启动，运行，到结束 运行/使用中的程序 ③线程 进程>线程 CPU 双核四线程 六核六线程 线程可以说是进程的一个小任务，一个进程可以有多个线程 游戏——王者荣耀 ：代码，图片素材，运行：图片需要在屏幕上绘制出来，技能引起数据变化 2.java如何实现线程 Thread类：继承于Runnalble类 ①继承 ②重写run方法 ③使用线程 -.
C++多线程深度解析：原理与线程池实战教程
"C++多线程从原理到线程池实战" 是一款专为C++开发者设计的深入学习课程，它旨在提升程序员对多线程编程的理解和技能。课程内容涵盖了多线程的基本原理，如线程的创建、管理和销毁，以及线程同步和互斥控制，这些都...
C++简易版游戏引擎开发与多线程应用实践
最新发布
09-26
内容概要：本文章介绍了一款用于练习C++编程技巧的简易游戏引擎的设计与实现，涉及模板编程、智能指针管理和多线程同步的知识点。文中提供了具体的代码实例来展示如何创建和更新游戏对象的位置以及进行游戏模拟运行...
C++程序设计：期末作业潜艇大战小游戏完整代码+程序+报告.zip
05-31
在本项目中，我们主要探讨的是一个基于C++编程语言实现的潜艇大战小游戏。这个程序设计的期末作业展示了C++在开发游戏应用方面的强大能力，包括面向对象编程、图形用户界面（GUI）的设计以及游戏逻辑的实现。让我们...
C++并发编程：可等待任务线程池与RS232通讯
在IT行业中，线程池是一种高效的线程管理策略，尤其在多线程和并行编程中至关重要。线程池允许预先创建一组线程，这些线程可以复用以执行多个任务，而无需每次任务完成后都创建新的线程。这种设计提高了系统性能，...
基于多线程的简单小游戏的制作
03-25
此游戏的工程 博文链接：https://hwfantasy.iteye.com/blog/1142136
C++实现一个线程池
weixin_45131842的博客
04-23 145
使用C++写一个最简单的线程池
九、Linux系统编程：线程池编程
小脑斧的博客
05-26 272
线程池编程
多线程小游戏
Sean的世界
10-27 904
[size=large][b][align=center]多线程小游戏[/align][/b] [/size] [size=medium] [align=center] ——泡泡堂练习[/align][/size] [b][size=medium]项目截图：[/size][/b] [align=center][img]http://dl.ite...
一文带你使用c++实现线程池！！！
qq_44778436的博客
12-30 2485
使用c++实现一个简单的线程池.
C++实现线程池、内存池
weixin_51142836的博客
08-05 305
C++实现线程池、内存池。以及整理了代码涉及到的知识点。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值