Studying-多线程学习Part4 - 异步并发——async future、packaged_task、promise

异步并发——async future packaged_task promise

1.async、future

是C++11引入的一个函数模版，用于异步执行一个函数，并返回一个future对象，表示异步操作的结果。使用 async 可以方便地进行异步编程，避免了手动创建线程和管理线程的麻烦。 

代码参考：

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

int func() {
	int i = 0;
	for (int j = 0; j < 1000; ++j) {
		i++;
	}
	return i;
}

int main() {
	future<int> future_result = async(launch::async, func);
	cout << func() << endl;
	cout << future_result.get() << endl;

	return 0;
}

这个例子中，使用了async函数异步执行了一个耗时的计算，这个计算可以在另一个线程中执行，不会阻塞主线程。同时，我们也避免了手动创建线程和管理线程的麻烦。

2.packaged_task 

在C++中，packaged_task是一个类模板，用于将一个可调用对象（如函数、函数对象或Lambda表达式）封装成一个异步撮作，并返回一个std::future对象，表示异步操作的结果。packaged_task可以方便地将一个函数或可调用对象转换成一个异步操作，供其他线程使用。

代码参考：

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

int func() {
	int i = 0;
	for (int j = 0; j < 1000; ++j) {
		i++;
	}
	return i;
}

int main() {
	packaged_task<int()> task(func);
	future<int>future_result = task.get_future();
	thread t1(move(task));

	cout << func() << endl;
	t1.join();
	cout << future_result.get() << endl;

	return 0;
}

在这个例子中，我们成功地将一个函数封装成了一个异步操作，并在其他线程中执行。通过packaged_task和future对象，我们可以方便地实现异步编程，使得代码更加简洁和易于维护。 

3.promise

在C++中，promise是一个类模版，用于在一个线程中产生一个值，并在另一个线程中获取这个值。promise通常与future和async一起使用，用于实现异步编程。

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

void fun(promise<int>& f) {
	f.set_value(1000); //传入数据
}

int main() {
	promise<int> f;
	auto future_result = f.get_future();
	thread t1(fun, ref(f));

	t1.join();
	cout << future_result.get() << endl;
	return 0;

}

实现一个数据的传入和使用。 

---

原子操作 atomic

`std::atomic` 是 C++11 标准库中的一个模板类，用于实现多线程环境下的原子操作。它提供了一种线程安全的方式来访问和修改共享变量，可以避免多线程环境中的数据竞争问题。

`std::atomic` 的使用方式类似于普通的 C++ 变量，但是它的操作是原子性的。也就是说，在多线程环境下，多个线程同时对同一个 `std::atomic` 变量进行操作时，不会出现数据竞争问题。

以下是一些常用的 `std::atomic` 操作：

1. `load()`：将 `std::atomic` 变量的值加载到当前线程的本地缓存中，并返回这个值。
2. `store(val)`：将 `val` 的值存储到 `std::atomic` 变量中，并保证这个操作是原子性的。
3. `exchange(val)`：将 `val` 的值存储到 `std::atomic` 变量中，并返回原先的值。
4. `compare_exchange_weak(expected, val)` 和 `compare_exchange_strong(expected, val)`：比较 `std::atomic` 变量的值和 `expected` 的值是否相同，如果相同，则将 `val` 的值存储到 `std::atomic` 变量中，并返回 `true`；否则，将 `std::atomic` 变量的值存储到 `expected` 中，并返回 `false`。

代码参考：

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

//原子量
atomic<int> sharted_data = 0;
void func() {
	for (int i = 0; i < 10000; ++i) {
		sharted_data++; //对原子量数据操作是线程安全的 
	}
}
int main() {
	thread t1(func);
	thread t2(func);
	t1.join();
	t2.join();
	cout << sharted_data << endl;
	return 0;
}