C++多线程实例

最新推荐文章于 2025-06-26 18:21:59 发布
原创 最新推荐文章于 2025-06-26 18:21:59 发布 · 707 阅读 · 5 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #开发语言

文章详细介绍了C++中实现多线程的几种方法，包括使用`once_flag`确保初始化的原子性，利用互斥体和锁避免数据竞争，以及如何通过条件变量避免死锁。此外，还探讨了异步编程和`future`在处理并发任务中的应用，并展示了C++17的并行算法在排序操作上的性能比较。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

线程精讲
https://paul.pub/cpp-concurrency/

  1. 初始化一次
#include <iostream>
#include <thread>
#include <mutex>

using namespace std;

void init()
{
	cout << "Initialing..." << endl;
}

void worker(once_flag *flag)
{
	call_once(*flag, init);
}

int main()
{
	once_flag flag;

	thread t1(worker, &flag);
	thread t2(worker, &flag);
	thread t3(worker, &flag);

	t1.join();
	t2.join();
	t3.join();

	return 0;
}
  1. 互斥体与锁
#include <iostream>
#include <thread>
#include <mutex>
#include <vector>

using namespace std;

static const int MAX = 10e8;
static double sum = 0;

static mutex exclusive;

void concurrent_worker(int min, int max)
{
	double dTmp = 0;
	for (int i = min; i <= max; ++i)
	{
		dTmp += sqrt(i);
	}

	exclusive.lock();
	sum += dTmp;
	exclusive.unlock();
}

void concurrent_task(int min, int max)
{
	auto start_time = chrono::steady_clock::now();
	unsigned concurrent_count = thread::hardware_concurrency();
	cout << "hardware_concurrency:" << concurrent_count << endl;
	vector<thread> threads;
	min = 0;
	sum = 0;
	for (int t = 0; t < concurrent_count; ++t)
	{
		int range = max / concurrent_count * (t + 1);
		threads.push_back(thread(concurrent_worker, min, range));
		min = range + 1;
	}

	for (int i = 0; i < threads.size(); ++i)
	{
		threads[i].join();
	}

	auto end_time = chrono::steady_clock::now();
	auto ms = chrono::duration_cast<chrono::milliseconds>(end_time - start_time).count();
	cout << "Concurrent task finish, " << ms << "ms consumed, Result: " << sum << endl;

}

int main()
{
	
	concurrent_task(0, 9999999999999999);
	return 0;
}
  1. 避免死锁
#include <iostream>
#include <thread>
#include <mutex>
#include <vector>
#include <set>
#include <string>

using namespace std;

class Account
{

public:
	Account(string name, double money) : m_name(name), m_money(money) {};

public:
	void changeMoney(double amount)
	{
		m_money += amount;
	}

	string getName()
	{
		return m_name;
	}

	double getMoney()
	{
		return m_money;
	}

	mutex* getLock()
	{
		return &m_mtx;
	}

private:
	string m_name;
	double m_money;
	mutex m_mtx;
};

class Bank
{
public:
	void addAccount(Account *account)
	{
		m_Accounts.insert(account);
	}

	bool transferMoney(Account* accountA, Account* accountB, double amount)
	{
		lock(*accountA->getLock(), *accountB->getLock());

		lock_guard<mutex> guardA(*accountA->getLock(), adopt_lock);
		lock_guard<mutex> guardB(*accountB->getLock(), adopt_lock);

		if (amount > accountA->getMoney())
		{
			return false;
		}

		accountA->changeMoney(-amount);
		accountB->changeMoney(+amount);
		return true;
	}

	double totalMoney() const
	{
		double sum = 0;
		for (auto a : m_Accounts)
		{
			sum += a->getMoney();
		}
		return sum;
	}


private:
	set<Account*> m_Accounts;
};

void randomTransfer(Bank* bank, Account* accountA, Account* accountB)
{
	static mutex s_mtx;
	while (true)
	{
		double randomMoney = ((double)rand() / RAND_MAX) * 100;
		if (bank->transferMoney(accountA, accountB, randomMoney))
		{
			lock_guard<mutex> lock(s_mtx);
			std::cout << "Transfer" << randomMoney << "from" 
				<< accountB->getName()
				<< "to" << accountB->getName()
				<< ",Bank totalMoney:" << bank->totalMoney() << endl;
			
		}
		else
		{
			lock_guard<mutex> lock(s_mtx);
			cout << "Transfer failed, "
				<< accountA->getName() << " has only $" << accountA->getMoney() << ", but "
				<< randomMoney << " required" << endl;
		}
	}
}

int main()
{
	Account a("Paul", 100.0);
	Account b("Moiral", 100.0);

	Bank bank;
	bank.addAccount(&a);
	bank.addAccount(&b);

	thread t1(randomTransfer, &bank, &a, &b);
	thread t2(randomTransfer, &bank, &b, &a);

	t1.join();
	t2.join();
	


	return 0;
}

4.条件变量优化死锁

#include <iostream>
#include <thread>
#include <mutex>
#include <vector>
#include <set>
#include <string>

using namespace std;

class Account
{

public:
	Account(string name, double money) : m_name(name), m_money(money) {};

public:
	void changeMoney(double amount)
	{
		unique_lock<mutex> lock(m_mtx);
		m_condition.wait(lock, [this, amount]()
		{
			return m_money + amount > 0;
		});
		m_money += amount;
		m_condition.notify_all();
	}

	string getName()
	{
		return m_name;
	}

	double getMoney()
	{
		return m_money;
	}

	mutex* getLock()
	{
		return &m_mtx;
	}

private:
	string m_name;
	double m_money;
	mutex m_mtx;
	condition_variable m_condition;
};

class Bank
{
public:
	void addAccount(Account *account)
	{
		m_Accounts.insert(account);
	}

	bool transferMoney(Account* accountA, Account* accountB, double amount)
	{
		accountA->changeMoney(-amount);
		accountB->changeMoney(+amount);
		return true;
	}

	double totalMoney() const
	{
		double sum = 0;
		for (auto a : m_Accounts)
		{
			sum += a->getMoney();
		}
		return sum;
	}


private:
	set<Account*> m_Accounts;
};

void randomTransfer(Bank* bank, Account* accountA, Account* accountB)
{
	static mutex s_mtx;
	while (true)
	{
		double randomMoney = ((double)rand() / RAND_MAX) * 100;
		
		{
			lock_guard<mutex> lock(s_mtx);
			std::cout << "Transfer" << randomMoney << "from" 
				<< accountB->getName()
				<< "to" << accountB->getName()
				<< ",Bank totalMoney:" << bank->totalMoney() << endl;
			
		}
		bank->transferMoney(accountA, accountB, randomMoney);
	}
}

int main()
{
	Account a("Paul", 100.0);
	Account b("Moiral", 100.0);

	Bank bank;
	bank.addAccount(&a);
	bank.addAccount(&b);

	thread t1(randomTransfer, &bank, &a, &b);
	thread t2(randomTransfer, &bank, &b, &a);

	t1.join();
	t2.join();
	


	return 0;
}

5.异步方式执行多线程

#include <iostream>
#include <thread>
#include <mutex>
#include <vector>
#include <set>
#include <string>
#include <future>

using namespace std;

static const int MAX = 10e8;
static double sum = 0;

void worker(int min, int max)
{
	cout << "work_thread_id" << this_thread::get_id() << endl;
	for (int i = min; i <= MAX; ++i)
	{
		sum += sqrt(i);
	}
}

int main()
{
	sum = 0;
	cout << "main_thread_id" << this_thread::get_id() << endl;
	auto f1 = async(launch::async, worker, 0, MAX);
	cout << "Async task triggered" << endl;
	f1.wait();
	cout << "Async task finish, result: " << sum << endl;


	return 0;
}
  1. 对类中函数执行异步线程操作
#include <iostream>
#include <thread>
#include <mutex>
#include <vector>
#include <set>
#include <string>
#include <future>

using namespace std;

class Worker
{
public:
	Worker(int min, int max) : m_min(min), m_max(max){}
	double work()
	{
		m_result = 0;
		for (int i = m_min; i <= m_max; ++i)
		{
			m_result += sqrt(i);
		}
		return m_result;
	}

	double getResult()
	{
		return m_result;
	}


private:
	int m_min;
	int m_max;
	double m_result;
};


int main()
{
	Worker w(0, 9999999999999999);
	cout << "Task in class triggered" << endl;
	auto f3 = async(&Worker::work, &w);
	f3.wait();
	cout << "Task in class finish, result: " << w.getResult() << endl;
	return 0;
}
  1. packaged_task获取异步操作结果的值
#include <iostream>
#include <thread>
#include <mutex>
#include <vector>
#include <set>
#include <string>
#include <future>

using namespace std;

double concurrent_worker(int min, int max)
{
	double sum = 0;
	for (int i = min; i < max; ++i)
	{
		sum += sqrt(i);
	}

	return sum;
}

double concurrent_task(int min, int max)
{
	vector<future<double>> results;

	unsigned concurrent_count = thread::hardware_concurrency();
	min = 0;
	for (int i = 0; i < concurrent_count; ++i)
	{
		packaged_task<double(int, int)> task(concurrent_worker);
		results.push_back(task.get_future());

		int range = max / concurrent_count * (i + 1);
		thread t(std::move(task), min, range);
		t.detach();

		min = range + 1;
	}

	cout << "threads create finish" << endl;
	double sum = 0;
	for (auto& r : results)
	{
		sum += r.get();
	}

	return sum;
}


int main()
{
	auto start_time = chrono::steady_clock::now();
	double r = concurrent_task(0, 9999);
	auto end_time = chrono::steady_clock::now();
	auto ms = chrono::duration_cast<chrono::microseconds>(end_time - start_time).count();
	cout << "Concurrent task finish, " << ms << "ms consumed, Result:" << r << endl;
	return 0;
}
  1. promise与future 任务结束与返回结果分开
#include <iostream>
#include <thread>
#include <mutex>
#include <vector>
#include <set>
#include <string>
#include <future>

using namespace std;

double concurrent_worker(int min, int max)
{
	double sum = 0;
	for (int i = min; i < max; ++i)
	{
		sum += sqrt(i);
	}

	return sum;
}

void concurrent_task(int min, int max, promise<double>* result)
{
	vector<future<double>> results;

	unsigned concurrent_count = thread::hardware_concurrency();
	min = 0;
	for (int i = 0; i < concurrent_count; ++i)
	{
		packaged_task<double(int, int)> task(concurrent_worker);
		results.push_back(task.get_future());

		int range = max / concurrent_count * (i + 1);
		thread t(std::move(task), min, range);
		t.detach();

		min = range + 1;
	}

	cout << "threads create finish" << endl;
	double sum = 0;
	for (auto& r : results)
	{
		sum += r.get();
	}

	result->set_value(sum);
	cout << "concurrent_task finish" << endl;
}


int main()
{
	auto start_time = chrono::steady_clock::now();

	promise<double> sum;
	concurrent_task(0, 9999, &sum);

	auto end_time = chrono::steady_clock::now();
	auto ms = chrono::duration_cast<chrono::microseconds>(end_time - start_time).count();
	cout << "Concurrent task finish, " << ms << "ms consumed, Result:" << sum.get_future().get() << endl;
	return 0;
}

8.C++17的并行算法


void generateRandomData(vector<double>& collection, int size) {
	random_device rd;
	mt19937 mt(rd());
	uniform_real_distribution<double> dist(1.0, 100.0);
	for (int i = 0; i < size; i++) {
		collection.push_back(dist(mt));
	}
}

int main() {
	vector<double> collection;
	generateRandomData(collection, 10e6); // ①

	vector<double> copy1(collection); // ②
	vector<double> copy2(collection);
	vector<double> copy3(collection);

	auto time1 = chrono::steady_clock::now(); // ③
	sort(execution::seq, copy1.begin(), copy1.end()); // ④
	auto time2 = chrono::steady_clock::now();
	auto duration = chrono::duration_cast<chrono::milliseconds>(time2 - time1).count();
	cout << "Sequenced sort consuming " << duration << "ms." << endl; // ⑤

	auto time3 = chrono::steady_clock::now();
	sort(execution::par, copy2.begin(), copy2.end()); // ⑥
	auto time4 = chrono::steady_clock::now();
	duration = chrono::duration_cast<chrono::milliseconds>(time4 - time3).count();
	cout << "Parallel sort consuming " << duration << "ms." << endl;

	auto time5 = chrono::steady_clock::now();
	sort(execution::par_unseq, copy2.begin(), copy2.end()); // ⑦
	auto time6 = chrono::steady_clock::now();
	duration = chrono::duration_cast<chrono::milliseconds>(time6 - time5).count();
	cout << "Parallel unsequenced sort consuming " << duration << "ms." << endl;
}
C++ 多线程举例
xiaoc100200的博客
06-20 243
通过这些示例，我们展示了如何在C++中使用多线程，包括创建和启动线程、传递参数、线程间同步以及条件变量的使用。多线程编程在提高程序并发性能方面非常有用，但需要注意同步和数据竞争问题，以确保线程安全。
C++多线程编程（入门实例）
weixin_33834137的博客
09-27 449
      　　多线程在编程中有相当重要的地位，我们在实际开发时或者找工作面试时总能遇到多线程的问题，对多线程的理解程度从一个侧面反映了程序员的编程水平。 　　其实C++语言本身并没有提供多线程机制（当然目前C++ 11新特性中，已经可以使用std::thread来创建线程了，因为还没有系统地了解过，所以这里不提了。），但Windows系统为我们提供了相关API，我们可以使用他们来进行多线...
c++多线程编程
最新发布
小刘同学321的博客
06-26 657
C++11多线程编程，涵盖线程创建、同步、异步、线程池与原子操作。
【多线程】C/C++语言中多线程和简单例子
bandaoyu的note
12-21 4286
前言： 1.linux线程执行和windows不同，pthread有两种状态joinable状态和unjoinable状态，如果线程是joinable状态，当线程函数自己返回退出时或pthread_exit时都不会释放线程所占用堆栈和线程描述符（总计8K多）。只有当你调用了pthread_join之后这些资源才会被释放。若是unjoinable状态的线程，这些资源在线程函数退出时或pthread_.........
C++ 简单的多线程例子
L946494的博客
08-31 688
概要：创建一个线程，主线程执行时，有另外一个线程也在运行 主要步骤： 1、创建一个线程 2、创建线程所要执行的函数 代码： #include <iostream> // 因为需要windows的API函数 #include<Windows.h> DWORD WINAPI Fun1Pro( __in LPVOID lpParameter ); int main() { int index = 0; // main 函数是主线程 //创
c++多线程实例
hi_baymax的博客
09-24 1175
转自：https://blog.youkuaiyun.com/naibozhuan3744/article/details/78746292 主要总结了基于C++的多线程函数CreateThread，互斥锁（或者称资源独占）函数CreateMutex，等待资源函数WaitForSingleObject，关闭线程函数(其实是关闭线程的句柄)CloseHanlde，释放互斥锁函数ReleaseMutex的用法实...
c++多线程编程的十个例子
08-21
以下是对“C++多线程编程的十个例子”的详细讲解，这些例子将帮助你在Windows环境下深入理解和应用多线程。 1. **创建线程** C++11引入了`std::thread`库来创建和管理线程。例如，你可以通过传递函数或成员函数...
linux下的C\C++多进程多线程编程实例详解
01-20
linux下的C\C++多进程多线程编程实例详解 1、多进程编程 #include #include #include <unistd> int main() { pid_t child_pid; /* 创建一个子进程 */ child_pid = fork(); if(child_pid == 0) { printf...
C++ 多线程实例
qq_33789118的博客
03-04 565
使用C++实现多线程实例【ubuntu16.04环境】 需要引用头文件：`thread` 注意：编译时 g++ <filename.cpp> -o main -lpthread -std=c++11 如果不添加编译选项：`lpthread` 则会报错：`collect2: error: ld returned 1 exit status` 多线程代码实例 #...
C++多线程例子
03-05
本教程将深入探讨C++中的多线程编程，并提供一个基础的例子。 C++11标准引入了对多线程的支持，通过`<thread>`库提供了线程创建、同步和通信等功能。在C++11之前，多线程通常依赖于平台特定的API，如POSIX的`...
c++ 多线程学习入门篇精讲（1）
dangforever的博客
03-21 1020
目录 基本概念C++中的多线程示例1：创建线程并执行函数 示例2：传递参数给线程函数示例3：使用Lambda表达式 线程同步什么是线程同步？为什么需要线程同步？（1）数据竞争（Data Race）的例子（2）不一致状态（Inconsistent State）的例子数据竞争和不一致状态的区别 尝试手动加锁解决问题手动实现锁的问题C++ 中的线程同步机制示例4：使用std::mutex进行线程同步（补充）关于emplace_back与 push_back 的区别（补充）关于基于范围的for循环（补充）关于aut
c++多线程代码实例
09-27
运用c++代码实现多线程同步互斥问题，文档内为最基础c++代码，新手也可看懂
C++多线程代码实例
当当的博客
09-27 9886
1. 本次调试代码用的是codeblocks16.01，需先配置好编译器 进入Setting-&amp;amp;gt;Compiler，勾选图示选项，点击确定。 2. 代码段 #include &amp;amp;lt;iostream&amp;amp;gt; #include &amp;amp;lt;thread&amp;amp;gt; #include &amp;amp;lt;mutex&amp;amp;gt; using namespace st
C++多线程示例
weixin_42877426的博客
05-08 270
//thread是c++11后的特性 #include <iostream> #include <thread> #include <mutex> using namespace std; void func_1(unsigned int & counter); void func_2(unsigned int & counter); mutex mtx; int main(){ unsigned int counter = 0;
C++多线程编程
ckh2007的专栏
01-08 3220
今天我给大家讲一讲C++中的多线程编程技术，C++本身并没有提供任何多线程机制，但是在windows下，我们可以调用SDK win32 api来编写多线程的程序，下面我就此简单的讲一下：创建线程的函数  HANDLE CreateThread(     LPSECURITY_ATTRIBUTES lpThreadAttributes, // SD    SIZE_T dwStackSize
C++多线程的简单例子
小勇博客
02-10 740
例1： 运行结果： 例2： 运行结果：
C++ 多线程编程实例
seekcreation的专栏
10-14 1810
从网上搜集来的非常基础的C++多线程实例，刚入门的可以看看，希望能有所帮助。 Cpp代码  //这是2个线程模拟卖火车票的小程序    #include     #include        DWORD WINAPI Fun1Proc(LPVOID lpParameter);//thread data    DWORD WINAPI Fun2Proc(LPVOID lp
C++多线程-实现示例
Chasing的博客
10-30 1377
需求：在ROS中，通过捕捉按键输入完成飞机的模式切换，该方式比较适合多机一键起飞或者其他模式切换操作。 简单说明：采用的是C++标准库提供的cin函数，但是这种方式为阻塞等待键盘按下，所以需要采用多线程或者多进程的方式，又采用了的是共享变量（标志位）的想法，故在一个进程中采用多线程即可。下面的示例给出一个简单的实现模板。在ROS中可以直接编译执行，在单C++函数中，需要在g++ -lpthread完成编译。join的作用为主函数运行结束后，子线程仍然可以一直运行，而不是一起结束。 #include <
c++全网最简单多线程实例
weixin_42703673的博客
07-22 267
_beginthread(func,0,NULL);//创建线程 _endthread();//结束线程 void func(void *arg); 需要注意的是线程函数的定义格式 #include<iostream> using namespace std; void func(void *arg) { int i=0; while(i<1000) { cout<<"线程BBBBB-"<<i++<<endl; ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值