函数与回调
ref
- 包装对象的引用，在传递参数时消除对象拷贝的代价，或者将不可拷贝的对象变为可以拷贝。
reference_wrapper
- boost::cref
- boost::ref
- unwrap_ref
|
1 2 3 4 5 |
int x = 10; reference_wrapper<int> rw(x); unwrap_ref(rw)insert(12); |
bind
- 适配任意的可调用对象，如函数指针、函数引用、成员函数指针、函数对象以及lambda。
- 第一个参数必须是一个可调用对象，之后最多接受9个参数。
|
1 2 3 4 5 6 7 8 9 10 11 |
int f(int a, int b) { return a + b; } std::cout << bind(f, 1, 2)() << std::endl; // 成员函数 bind(&X::func, x, _1, _2, ...); // 成员变量 transform(v.begin(), v.end(), v2.begin(), bind(&point::x, _1)); |
function
- 一个函数对象的“容器”。以对象的形式封装了原始的函数指针或函数对象，能够容纳任意符合函数签名的可调用对象。
- clear：将函数对象置空
- contains：检测function是否持有一个可调用对象
- target：返回function对象内部持有的可调用对象的指针，为空则返回nullptr
|
1 2 3 4 5 6 7 8 9 10 |
function<int()> func; function<int(int a, int b, int c)> func2; function<int(int, int, int)> func3; int f(int a, int b) { return a + b; } function<int(int, int)> func4 = f; std::cout << func4(1, 2) << std::endl; |
signals2
- 线程安全的观察者模式。一个信号关联多个插槽，当信号发出时，所有关联的槽都会被调用。
|
1 2 3 4 5 6 7 8 9 10 11 12 |
void slots1() { std::cout << "slots1" << std::endl; } void slots2() { std::cout << "slots2" << std::endl; } signal<void()> sig; sig.connect(&slots1); sig.connect(&slots2); sig(); |
并发编程
atomic
- 原子操作库。
|
1 2 3 |
atomic<int> a(10); atomic<bool> b{false}; |
mutex
null_mutex
- 无任何锁定功能的“互斥量”
mutex
- 独占式的互斥量
timed_mutex
- 独占式的互斥量，提供超时锁定功能
recursive_mutex
- 递归式互斥量，可多次锁定，但也需多次解锁
recursive_timed_mutex
- 递归式互斥量，增加了超时锁定功能
shared_mutex
- 读写锁
|
1 2 3 4 5 6 7 8 |
mutex mu; try { mu.lock(); // ... mu.unlock(); } catch (...) { mu.unlock(); } |
|
1 2 3 4 5 6 |
timed_mutex mu; auto flag = mu.try_lock_for(100_ms); if (flag) { // ... mu.unlock(); } |
lock_guard
unique_lock
make_unique_lock
thread
- get_id：同线程的同名函数，获取thread::id
- yield：指示当前线程放弃时间片，允许其他线程运行
- sleep_for：线程睡眠等待一小段时间
- sleep_until：线程睡眠等待至一个时间点
- join：一直阻塞等待，直到线程结束
- try_join_for/try_join_until：阻塞等待一定的时间段，然后不管线程是否结束都返回
- detach：将thread和线程执行体手动分离
thread_guard
|
1 2 3 4 5 6 7 8 |
thread t1(test, 10); thread t2(test, 20); // 析构后线程继续运行 thread_guard<detach> g1(t1); // 析构时等待线程结束 thread_guard<> g2(t2); |
scoped_thread
|
1 2 |
scoped_thread<detach> t1(test, 10); scoped_thread<> t2(test, 20); |
中断线程
- interrupt
- interruption_requested
thread_group
- 管理一组线程，就像是一个线程池。
call_once
- 用于在多线程环境下仅调用一次。
|
1 2 3 4 5 6 7 8 9 10 |
int g_count; void init_count(int x) { std::cout << "call once" << std::endl; g_count = x; } void call_func() { static once_flag once; call_once(once, init_count, 10); } |
condition_variable
- 必须要与互斥量配合使用，等待另一个线程中某个事件的发生，然后线程才继续执行。
future
- 用来存储异步计算得到的值。它只能持有结果的唯一一个引用。
- wait：阻塞等待线程的执行，知道获得future的值
- wait_for/wait_until：增加了超时的功能
- get：获取future的值
- valid/is_ready：future是否可用
- has_value,has_exception：是否有值或发生了异常
async
- 异步启动一个线程运行函数，返回future对象
多个future
shared_future
本文为原创文章，版权归Aet所有，欢迎分享本文，转载请保留出处！
你可能也喜欢
- ♥ Boost 程序库完全开发指南：容器算法数学文件08/24
- ♥ C++11_四种类型转换11/10
- ♥ Spdlog记述：三07/23
- ♥ 51CTO：Linux C++网络编程一08/13
- ♥ C++_运算符优先级&&相关性12/15
- ♥ Soui四05/23