sql 之 c++测试代码

/// 这是一个测试文件
/// 主要测试从mysql数据库并发读取数据的性能
/// 目前测试的有：
/// 开启8个线程，每个线程执行10000/8次读取
/// 每次读取1w-10w的数据量




#include <iostream>
#include <fstream>
#include <ostream>
#include <list>
#include <thread>
#include <functional>
#include <cassert>
#include <atomic>
#include <chrono>
#include <sys/time.h>
#include <pthread.h>
//其他头文件

void TestConcurrentReadDataFromMysql(uint64_t uid, uint32_t threadCnt, uint32_t size, std::atomic<int>& currentThreadCnt)
{
	struct StatisticsTimeConsume
	{
		uint32_t _size;
		struct timeval _t;
	};
	typedef std::list < StatisticsTimeConsume > list_timeConsume;


	auto funcReadDataFromMysql = [](uint64_t uid, list_timeConsume& ltc){
		struct timeval t_start, t_end, t_diff;

		//开始计时
		gettimeofday(&t_start, NULL);
		//从数据库读取数据
		//一次读取的数据量在数据库中控制，比如一次要读取1w条数据，那么在数据库中插入1w条数据即可！
		RWMysql::ReadUserStatisticsAlltimes(uid);
		//读取数据耗时统计
		gettimeofday(&t_end, NULL);
		t_diff.tv_sec = t_end.tv_sec - t_start.tv_sec;
		t_diff.tv_usec = t_end.tv_usec - t_start.tv_usec;

		ltc.push_back(StatisticsTimeConsume());
		StatisticsTimeConsume& item = ltc.back();
		</span>//查询因为每次查询一次，所以这里为1，如果是读取表，那么这里应该是一次读取的数据量的大小
		item._size = 1;
		item._t = t_diff;
	};

	auto funcStatisticsWriteFile = [](const list_timeConsume& ltc, const std::string& fileName){
		fstream ofs(fileName, ios_base::out);
		if (!ofs.is_open()){
			assert(false);
			return;
		}

		struct timeval t_timeTotal;
		t_timeTotal.tv_sec = 0;
		t_timeTotal.tv_usec = 0;

		for (const StatisticsTimeConsume& i : ltc){
			ofs << i._size << ":" << i._t.tv_sec << " sec " << i._t.tv_usec << " usec\n";
			t_timeTotal.tv_sec += i._t.tv_sec;
			t_timeTotal.tv_usec += i._t.tv_usec;
		}
		ofs << "\nmilliseconds = usec / 1000\n";
		ofs << "total time:" << ":" << t_timeTotal.tv_sec << " sec " << t_timeTotal.tv_usec << " usec\n";

		ofs.close();
	};

	class ResourceProtect{
	public:
		ResourceProtect(std::atomic<int>& a) :_a(a){ ++_a; }
		~ResourceProtect(){ --_a; }
	private:
		std::atomic<int>& _a;
	};

	auto funcThreadRun = [funcReadDataFromMysql, funcStatisticsWriteFile](uint64_t uid, uint32_t size, std::atomic<int>& currentThreadCnt){
		auto funcThreadCallaback = [funcReadDataFromMysql, funcStatisticsWriteFile](uint64_t uid, uint32_t size, std::atomic<int>& currentThreadCnt){
			ResourceProtect rp(currentThreadCnt);
			cout << "thread: " << pthread_self() << " start." << endl;

			list_timeConsume ltc;
			//执行size次读取
			for (uint32_t i = 0; i < size; i++){
				funcReadDataFromMysql(uid, ltc);
			}
			//用线程id作为文件名
			funcStatisticsWriteFile(ltc, "/home/wl/project/test/" + to_string(uid) + "_" + to_string(pthread_self()));
		};
		thread t(std::bind(funcThreadCallaback, uid, size, std::ref(currentThreadCnt)));
		t.detach();
	};
	
	//const uint64_t uids[] = {1, 2, 3, 4, 5, 6, 7, 8};
	for (uint32_t i = 0; i < threadCnt; i++){
		//每个线程执行size/threadCnt的次数
		//size是总次数
		funcThreadRun(i+1, size/threadCnt, std::ref(currentThreadCnt));
	}
}

void Test(uint64_t uid)
{
	uint32_t size = 80000;	//size的大小必须>=threadCnt
	uint32_t threadCnt = 8;

	std::atomic<int> currentThreadCnt;
	uint32_t execTotalTime = 0;

	//每个线程执行size/threadCnt的次数
	//size是总次数
	currentThreadCnt -= currentThreadCnt;
	TestConcurrentReadDataFromMysql(uid, threadCnt, size, currentThreadCnt);
	std::this_thread::sleep_for(std::chrono::milliseconds(100));
	while (currentThreadCnt > 0){
		std::this_thread::sleep_for(std::chrono::milliseconds(1000));
		++execTotalTime;
		cout << "wait for exec: " << execTotalTime << "s ...\n";
	}
	cout << "exec finished." << endl;
}