c++查询可以调动的线程个数

#include <iostream>
#include <thread>
 
int main() {
    // 查询可调动线程数量
    std::thread::hardware_concurrency();
 
    // 如果函数返回0，表示不支持并发，或者无法确定
    // 如果返回非0值，表示可以同时激活的线程数量
    unsigned int concurrency = std::thread::hardware_concurrency();
    std::cout << "可调动线程数量: " << concurrency << std::endl;
 
    return 0;
}

无返回值

在C++中处理大量数据时，可以使用多线程来提高处理速度。以下是一个简单的例子，展示了如何使用std::thread来并行处理数据集。

#include <iostream>
#include <vector>
#include <thread>
 
// 处理单个数据项的函数
void processData(const std::vector<int>& data, int threadIndex, int threadCount) {
    for (size_t i = threadIndex; i < data.size(); i += threadCount) {
        // 对数据项进行处理
        // 例如：std::cout << data[i] << std::endl;
    }
}
 
int main() {
    std::vector<int> data = {/* 初始化数据 */};
    const int threadCount = 4; // 假设我们想要4个线程
 
    std::vector<std::thread> threads;
    for (int i = 0; i < threadCount; ++i) {
        threads.emplace_back(processData, std::ref(data), i, threadCount);
    }
 
    for (auto& thread : threads) {
        thread.join(); // 等待所有线程完成
    }
 
    return 0;
}

有返回值

在C++中，创建一个有返回值的线程可以使用std::future和std::packaged_task。以下是一个简单的例子：

#include <iostream>
#include <future>
#include <thread>
 
// 函数返回一个整数
int returnValueFunction(int value) {
    return value * 2;
}
 
int main() {
    // 创建一个packaged_task
    std::packaged_task<int(int)> task(returnValueFunction);
 
    // 获取与task关联的未来
    std::future<int> result = task.get_future();
 
    // 创建线程并执行task
    std::thread t(std::move(task), 10);
 
    // 等待任务完成并获取结果
    int answer = result.get();
 
    std::cout << "The answer is " << answer << std::endl;
 
    // 清理线程资源
    t.join();
 
    return 0;
}

无返回值大数据

有返回值大数据

类内方法1
		int ConvertEntity(int  a1, double  a2,bool  a3,int  a4);//含形参和返回值要加线程的方法
类内方法2	通过线程调用类内方法1 且将结果加在类内变量里面
		// 定义线程要执行的函数，捕获myObject的引用
		auto threadFunction = [this](
			int a1,
			double a2,
			bool a3,
			int a4) {
				auto result = ConvertEntity(a1, a2, a3, a4);
				std::lock_guard<std::mutex> guard(mtx);//锁数据
				m_Dates.insert(m_Dates.begin(), result.begin(), result.end());
		};

		// 查询可调动线程数量
		std::thread::hardware_concurrency();

		// 如果函数返回0，表示不支持并发，或者无法确定
		// 如果返回非0值，表示可以同时激活的线程数量
		unsigned int threadCount = std::thread::hardware_concurrency();
		std::cout << "可调动线程数量: " << threadCount << std::endl;

		//获取当前时间点  
		auto start = std::chrono::high_resolution_clock::now();
		std::vector<std::list<DRW_Entity*>> _ents;
		int num = ents.size() / threadCount;
		std::vector<std::thread> threads;

		int startNum = 0;
		int endNum = 0;

		for (int i = 0; i < threadCount; ++i)
		{
			startNum = i == 0 ? 0 : endNum;
			endNum = (i == threadCount - 1) ? ents.size(): (endNum + num);
			threads.emplace_back(threadFunction,
				实参1,
				实参2,
				实参3,
				实参4);
		}
			// 等待所有线程完成
		for (auto& t : threads) {
			if (t.joinable()) {
				t.join();
			}
		}