一些C++11特性
了解一下lambda表达式，利用Lambda表达式，可以方便的定义和创建匿名函数
值捕获
int main()
{
int a = 123;
auto f = [a] { cout << a << endl; };
a = 321;
f(); // 输出：123
}
引用捕获
int main()
{
int a = 123;
auto f = [&a] { cout << a << endl; };
a = 321;
f(); // 输出：321
}
隐式捕获
int main()
{
int a = 123;
auto f = [=] { cout << a << endl; }; // 值捕获
f(); // 输出：123
}
int main()
{
int a = 123;
auto f = [&] { cout << a << endl; }; // 引用捕获
a = 321;
f(); // 输出：321
}
类型尾置
让编译器在函数定义的时候知道返回类型
template
auto &getItem(T begin, T end) -> decltype(*begin) {
return *begin; // 返回序列中一个元素的引用
}
线程相关操作
#include
#include
void foo() {
std::cout << "hello world" << std::endl;
}
int main() {
std::thread t(foo);//创建一个线程实例
t.join();//加入一个线程
return 0;
}
std::mutex mutex 创建一个互斥量
std::lock_guard lock(mutex); 对互斥量上锁
std::unique_lock 也是上锁,但更灵活
std::packaged_task task([](){return 7;}); 用来封装任何可以调用的目标，从而用于实现异步的调用，异步即主线程A想获取某个计算结果而调用线程B
std::future result = task.get_future(); 用来获取异步任务的结果
std::thread(std::move(task)).detach(); 一个线程中执行 task
std::this_thread::sleep_for 当前线程休眠一段时间，休眠期间不与其他线程竞争CPU，根据线程需求，等待若干时间
std::condition_variable 唤醒等待线程从而避免死锁
std::bind 将实参绑定到调用函数上
std::placeholders::_1 占用符
std::shared_ptr 一种智能指针，它能够记录多少个 shared_ptr 共同指向一个对象
std::make_shared 分配创建传入参数中的对象，并返回这个对象类型的std::shared_ptr指针
std::move 将自己的参数转换为右值
std::forward 会把参数被绑定到一个右值的时候将其转化为右值
std::result_of 在编译的时候推导出一个函数调用表达式的返回值类型
看一个操作系统中生产者与消费者问题
假设存在一个缓冲区，生产者往里面存数据，消费者从里面取数据，如果缓冲区满了,生产者就不能再往里面添加数据。如果缓冲区没有数据，消费者不能从里面取
下面利用c++11来写一个简单的模型，要理解多线程并发，一个程序可能由多个线程来执行，因此程序上的顺序并不同于多线程中的执行顺序，代码中先写5个生产者，再写5个消费者，但是线程中的顺序并不是这样，可能先执行一个生产者，再执行一个消费者。
#include
#include
#include
#include
#include
#include
int main()
{
// 生产者数量
std::queue produced_nums;
// 互斥锁
std::mutex m;
// 条件变量
std::condition_variable cond_var;
// 结束标志
bool done = false;
// 通知标志
bool notified = false;
// 生产者线程
std::thread producer([&]() {
for (int i = 0; i < 5; ++i) {
std::this_thread::sleep_for(std::chrono::seconds(1));//当前线程休眠
// 创建互斥锁
std::unique_lock lock(m);
std::cout << "producing " << i << '\n';
produced_nums.push(i);
notified = true;
// 通知一个线程
cond_var.notify_one();
}
done = true;//生产结束
cond_var.notify_one();//通知休眠的线程执行，完成所有的进程
});
// 消费者线程
std::thread consumer([&]() {
std::unique_lock lock(m);
while (!done) {
while (!notified) { // 循环避免虚假唤醒,执行完生产者的进程,notified为true,否则停掉消费者线程
cond_var.wait(lock);//停掉当前线程
}
while (!produced_nums.empty()) {
std::cout << "consuming " << produced_nums.front() << '\n';
produced_nums.pop();
}
notified = false;
}
});
producer.join();
consumer.join();
}
#ifndef ThreadPool_hpp
#define ThreadPool_hpp
#include // std::vector
#include // std::queue
#include // std::make_shared
#include // std::runtime_error
#include // std::thread
#include // std::mutex, std::unique_lock
#include // std::condition_variable
#include // std::future, std::packaged_task
#include // std::function, std::bind
#include // std::move, std::forward
class ThreadPool {
public:
inline ThreadPool(size_t threads) : stop(false) { //构造函数,且把stop变量赋值为false
for(size_t i = 0;i task;//function函数对象类,可调用实体的一种类型安全的包裹
{
std::unique_lock lock(this->queue_mutex);//互斥量上锁
//std::cout<<"thread"<condition.wait(lock,[this]{ return this->stop || !this->tasks.empty(); });//如果线程池没有销毁且任务队列为空，返回false，该线程休眠
if(this->stop && this->tasks.empty())//线程池销毁且任务队列为空，返回
return;
task = std::move(this->tasks.front());
this->tasks.pop();
}
task();//执行任务
}
std::cout<<"thread"< lock(queue_mutex);//互斥量上锁,避免
stop = true;
}
condition.notify_all();//通知所有的休眠线程
for(std::thread &worker: workers)
worker.join();
}
template
auto enqueue(F&& f, Args&&... args)//可变参数的模板,Args 是一个模板参数包。而在后面的函数参数表中，args 则是函数参数包，用来表示零个或多个参数。
-> std::future::type> {
using return_type = typename std::result_of::type;//获取函数返回类型
auto task = std::make_shared< std::packaged_task>(
std::bind(std::forward(f), std::forward(args)...)
);
std::future res = task->get_future();//获得 std::future 对象以供实施线程同步
{
std::unique_lock lock(queue_mutex);
if(stop)
throw std::runtime_error("enqueue on stopped ThreadPool");
tasks.emplace([task]{ (*task)(); });//把任务加入队列
}
condition.notify_one();//唤醒一个休眠的线程
return res;
}
private:
std::vector workers;//线程池
std::queue> tasks;//任务队列
std::mutex queue_mutex;//互斥量
std::condition_variable condition;//条件变量
bool stop;//结束标志
};
#endif /* ThreadPool_hpp */
伪代码：
semaphore mutex=1; //临界区互斥信号量
semaphore empty=n; //空闲缓冲区
semaphore full=0; //缓冲区初始化为空
producer ()//生产者进程
{
while(1)
{
produce an item in nextp; //生产数据
P(empty); //获取空缓冲区单元
P(mutex); //进入临界区.
add nextp to buffer; //将数据放入缓冲区
V(mutex); //离开临界区,释放互斥信号量
V(full); //满缓冲区数加1
}
}
consumer ()//消费者进程
{
while(1)
{
P(full); //获取满缓冲区单元
P(mutex); // 进入临界区
remove an item from buffer; //从缓冲区中取出数据
V (mutex); //离开临界区，释放互斥信号量
V (empty) ; //空缓冲区数加1
consume the item; //消费数据
}
}