C++11并发编程个人小结

thread_local变量在每个线程第一次执行到时初始化(类似static)，并在每个线程各自累加，并在线程结束时释放。

std::condition_variable::
　　wait(std::unique_lock<std::mutex>& lock, Predicate pred);
　　　　pred为true时直接返回；
　　　　pred为false时，lock必须满足已被当前线程锁定的前提。执行原子地释放锁定，阻塞当前线程，并将其添加到等待*this的线程列表中。
　　void notify_one();
　　　　激活某个等待*this的线程，被激活的线程重新获得锁。

async：能够保留线程的返回值。启动一个线程，或在期望等待时同步任务.
std::launch::async表明函数必须在其所在的独立线程上执行
std::launch::defered表明函数调用被延迟到wait()或get()函数调用时才执行
如果两者都行，取决于实现；未声明则未定义。

####################
线程相关的很多=默认是move语义。
thread：.join(), .detach(), .swap()
mutex：mutex, lock_guard, unique_lock等, .lock(), .unlock()
condition_variable：.notify_one(), .wait()//实现等待队列
future：
async: 类似于thread, 能保留返回值，可启动一个线程，或在期望等待时同步任务.
　　　　std::launch::async表明函数必须在其所在的独立线程上执行
　　　　std::launch::defered表明函数调用被延迟到wait()或get()函数调用时才执行
　　　　如果两者都行，取决于实现；未声明则未定义。
packaged_task: 构造时绑定一个函数对象，.get_future()将返回值绑定到future，再执行task函数（或传递到std::thread对象中可作为线程函数）
promise: .getfuture(), 绑定到future; 执行.set_value()后, 绑定的future可.get(), 否则.get()一直被阻塞直到.set_value()执行。
future: .share(), .wait(), .get()
　　　　当future的状态还不是就绪时就调用绑定的promise, packaged_task等的析构函数，会在期望里存储一个异常。
　　　　std::future有局限性，在很多线程等待时，只有一个线程能获取等待结果。
　　　　当多个线程需要等待相同的事件的结果，需要用shared_future来替代future。
　　　　shared_future与future类似，但shared_future可以拷贝、多个shared_future可以共享某个共享状态的最终结果(即共享状态的某个值或者异常)。
　　　　shared_future可通过某个future对象隐式转换，或通过future::share()显示转换，无论哪种转换，被转换的那个future对象都会变为not-valid.

atomic:
　　is_lock_free: 如果某个对象满足 lock-free 特性，在多个线程访问该对象时不会导致线程阻塞。
　　　　　　　　（其实看我们那副图就是说你的各个线程不会互相阻塞，
　　　　　　　　那么你的程序才能成为lock free的。
　　　　　　　　像我们平常用的互斥锁，当有线程获得锁，
　　　　　　　　其他线程就被阻塞掉了，
　　　　　　　　这里的问题就是如果获得锁的线程挂掉了，
　　　　　　　　而且锁也没有释放，那么整个程序其实就被block在那了，
　　　　　　　　而如果程序是lock free的那么即使有线程挂掉，
　　　　　　　　也不影响整个程序继续向下进行，
　　　　　　　　也就是系统在整体上而言是一直前进的。
　　　　　　　　大概系统内部自有一套判断机制）
　　store: 修改被封装的值
　　load: 读取被封装的值

内存模型：
　　要想写出高性能的多线程程序必须理解内存模型，
　　因为编译器会给你的程序做优化(如指令重排等)，
　　CPU为了提升性能也有多发射和乱序执行，
　　因此程序在最终执行时并不会按照你之前的原始代码顺序来执行，
　　所以内存模型是程序员、编译器，CPU 之间的契约，遵守契约后大家就各自做优化，从而尽可能提高程序的性能。
　　_relaxed: 不对执行顺序做任何保证
　　_acquire: 本线程中，所有后续的读操作必须在本原子操作完成后执行
　　_release: 本线程中，所有之前的写操作完成后才能执行本原子操作
　　_acq_rel: 同时包含acquire和release
　　_consume: 本线程中，所有后续的有关本原子类型的操作，必须在本原子操作完成后执行
　　_seq_cst: 全部存取按顺序执行

 =========================================================

PV原语: 信号量s, 除一个整数值s.cound, 还有一个进程等待队列s.queue, 是阻塞在该信号上的进程。

信号量的值为非负值表示当前空闲资源数, 负值表示当前阻塞在该信号上的进程。

P(Semaphore s) {--s.count; if(s.count < 0) 阻塞调用进程;}

V(Semaphore s) {++s.count; if(s.count <= 0) 唤醒某一进程;}

互斥量mutex就是count = 1的PV原语。

如何实现同步？考虑进程的DAG图, A进程的某个节点a有指向B进程的某个节点b, 那么相当于一开始b处于阻塞态, A进程到a处执行V原语释放资源。如公交司机开车停车与售票员开门关门。 

 

经典算法

生产者与消费者:(以下代码每个生产者生产数量与每个消费者消费数量相同)

/***************
首先你要有一个生产者和消费者公用的Buffer, 它要求用mutex和condition variable来实现锁
一个互斥量, 互斥地访问buffer, 多个消费者和生产者每个消费和生产的数量相同。
本写法本质为单消费者单生产者。
正确写法：
单生产者单消费者: 设置一个互斥量mtx, 互斥地访问buffer; 两个条件变量表示buffer满或空
多生产者单消费者: 再规定总生产量为count_produce, 多生产者互斥地访问count_produce
多生产者单消费者: 再规定总消费量为count_consume, 多消费者互斥地访问count_consume
多生产者单消费者: 再规定总生产量为count_produce, 多生产者互斥地访问count_produce, 规定总消费量为count_consume(count_consume = count_produce), 多消费者互斥地访问count_consume
***************/
#include <bits/stdc++.h>
struct BoundedBuffer {
    int* buffer;
    int capacity;

    int front;
    int rear;
    int count;

    std::mutex lock;

    std::condition_variable not_full;
    std::condition_variable not_empty;

    BoundedBuffer(int capacity) : capacity(capacity), front(0), rear(0), count(0) {
        buffer = new int[capacity];
    }
    ~BoundedBuffer(){
        delete[] buffer;
    }
    void deposit(int data){
        std::unique_lock<std::mutex> l(lock);
        not_full.wait(l, [this](){return count != capacity; });
        buffer[rear] = data;
        rear = (rear + 1) % capacity;
        ++count;
        not_empty.notify_one();
    }
    int fetch(){
        std::unique_lock<std::mutex> l(lock);
        not_empty.wait(l, [this](){return count != 0; });
        int result = buffer[front];
        front = (front + 1) % capacity;
        --count;
        not_full.notify_one();
        return result;
    }
};


void consumer(int id, BoundedBuffer& buffer){
    for(int i = 0; i < 50; ++i){
        int value = buffer.fetch();
        std::cout << "Consumer " << id << " fetched " << value << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(250));
    }
}

void producer(int id, BoundedBuffer& buffer){
    for(int i = 0; i < 75; ++i){
        buffer.deposit(i);
        std::cout << "Produced " << id << " produced " << i << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
}

int main(){
    BoundedBuffer buffer(200);

    std::thread c1(consumer, 0, std::ref(buffer));
    std::thread c2(consumer, 1, std::ref(buffer));
    std::thread c3(consumer, 2, std::ref(buffer));
    std::thread p1(producer, 0, std::ref(buffer));
    std::thread p2(producer, 1, std::ref(buffer));

    c1.join();
    c2.join();
    c3.join();
    p1.join();
    p2.join();

    return 0;
}

 参考链接

读者写者问题: 参考链接

哲学家进餐问题: 1.最多允许四个人同时在进餐 2.当两边筷子都可用时再去拿 3.每次先拿奇数号的筷子再拿偶数号的筷子 4.分成三种状态, 思考, 饥饿, 进餐, 并且一次拿一双