生产者消费者模型

生产者消费者模型：一个场景，两种角色(生产者、消费者)，三种关系(生产者与消费者同步互斥，生产者与生产者互斥，消费者与消费者互斥）

功能：解耦（耦合度：数据之间的依赖度)、支持忙闲不均、支持并发
 实现：1、实现线程安全的队列，对外提供线程安全的数据入队、出队操作
             2、创建线程，分别为生产者与消费者数据入队或数据出队。
 

/**********************************************************
 * Author        : WangWei
 * Email         : 872408568@qq.com
 * Last modified : 2019-05-19 14:08:35
 * Filename      : BlockQueue.cpp
 * Description   :C++模拟阻塞队列的生产者消费者模型 
 * *******************************************************/
#include <pthread.h>
#include <queue>
#include <stdlib.h>
#include <iostream>
using namespace std;

#define Num 10 

class BlockQueue {
private:
    std::queue<int> _q;
    size_t _capacity;

    pthread_mutex_t lock;
    pthread_cond_t _pro;
    pthread_cond_t _con;

private:
     void  QueueLock() {
        pthread_mutex_lock(&lock);
    }

     void QueueUnlock() {
         
        pthread_mutex_unlock(&lock);
    }

     void ProWait() {
         pthread_cond_wait(&_pro, &lock);
     }


     void ProWeakup() {
         pthread_cond_signal(&_pro);
     }

     
     void ConWait() {
         pthread_cond_wait(&_con, &lock);
     }
     void ConWeakup() {
         pthread_cond_signal(&_con);
     }

     bool IsFull() {
         if(_q.size() == _capacity) {
             return true;
         }

         return false;
     }

     bool IsEmpty() {
         return _q.empty();
     }

public:
    BlockQueue(size_t capacity = Num) {
        _capacity = capacity;

        pthread_mutex_init(&lock, NULL);
        pthread_cond_init(&_pro, NULL);
        pthread_cond_init(&_con, NULL);

    }

    void QueuePush(const int& data) {
        QueueLock();

        while(IsFull()) {
            // 先唤醒消费者,起来吃面
            ConWeakup();
            cout << "正在吃面..." << endl;
          
            // 生产者休息
            ProWait();
        }

        // 生产者做面
        _q.push(data);

        // 做好面叫醒消费者起来吃面
        ConWeakup();

        QueueUnlock();
    }

    void QueuePop(int& data) {
        QueueLock();

        while(IsEmpty()) {
            // 唤醒生产者，告诉他该起来做面了
            ProWeakup();
            cout << "正在做面..." << endl;

            // 消费者等待生产者做面
            ConWait();
        }

        // 吃面
        data = _q.front();
        _q.pop();

        // 吃完了让生产者继续做面
        ProWeakup();
        QueueUnlock();
    }

    ~BlockQueue() {

        pthread_mutex_destroy(&lock);
        pthread_cond_destroy(&_pro);
        pthread_cond_destroy(&_con);
       
    }
};

void* productor(void* args) {
    BlockQueue* q = (BlockQueue*)args;

    while(1) {
        int data;
        q->QueuePush(data);
        cout << "面做好了" << endl;
    }
}

void* consumer(void* args) {

    BlockQueue* q = (BlockQueue*)args;

    while(1) {
        int data;    
        q->QueuePop(data);
        cout << "面吃完了" << endl;
        }
}

int main() {

    BlockQueue q;

    pthread_t Ptid,Ctid;

    pthread_create(&Ptid, NULL, productor, (void*)&q);

    pthread_create(&Ctid, NULL, consumer, (void*)&q);
    
    pthread_join(Ptid, NULL);
    pthread_join(Ctid, NULL);
    return 0;
}

 POSIX信号量：具有等待与唤醒功能的计数器
        原理：通过自身的计数器实现条件判断，当条件满足时则直接返回，并且计数-1；条件不满足时则阻塞。
              当生产资源后，通过信号量的唤醒功能唤醒等待并且计数+1
        信号量和条件变量实现同步的区别：
            1、信号量的条件判断由自身完成，而条件变量的条件判断由用户完成。
            2、信号量并不搭配互斥锁使用，条件变量必须要搭配互斥锁一起使用(条件变量需要对临界资源进行操作)保护条件的改变
        
        信号量的操作步骤：
            sem_t         定义
            sem_init     初始化
            sem_wait      计数-1，判断是否阻塞
            sem_post     计数+1，唤醒阻塞
            sem_destroy   销毁
             
        使用顺序表实现环形队列：
                RingQueue{ 
                    std::vector<int> _queue;
                    int _capacity;
                    int _read_step;    // 环形队列读指针
                    int _write_step;  // 环形队列写指针
                    
                    // 使用信号量实现同步与互斥
                    sem_t sem_lock;       // 实现互斥
                    sem_t data_sem;      // 数据资源计数
                    sem_t space_sem;    // 空闲空间计数
                    };
                    
        线程池：一堆线程 + 任务队列（线程安全）
            作用：1、避免大量线程频繁的创建和销毁时间成本
                  2、避免瞬间大量线程创建耗尽资源导致程序崩溃
                  3、提高任务的并发处理性
            
            实现：创建固定数量的线程 + 创建一个线程安全的队列
                创建一个任务类
                创建线程池类：
                    1、创建线程
                    2、创建线程安全队列
 

线程池的种类及使用场景：

newCachedThreadPool：

底层：返回ThreadPoolExecutor实例，corePoolSize为0；maximumPoolSize为Integer.MAX_VALUE；keepAliveTime为60L；unit为TimeUnit.SECONDS；workQueue为SynchronousQueue(同步队列)
通俗：当有新任务到来，则插入到SynchronousQueue中，由于SynchronousQueue是同步队列，因此会在池中寻找可用线程来执行，若有可以线程则执行，若没有可用线程则创建一个线程来执行该任务；若池中线程空闲时间超过指定大小，则该线程会被销毁。
适用：执行很多短期异步的小程序或者负载较轻的服务器

newFixedThreadPool：

底层：返回ThreadPoolExecutor实例，接收参数为所设定线程数量nThread，corePoolSize为nThread，maximumPoolSize为nThread；keepAliveTime为0L(不限时)；unit为：TimeUnit.MILLISECONDS；WorkQueue为：new LinkedBlockingQueue() 无解阻塞队列
通俗：创建可容纳固定数量线程的池子，每隔线程的存活时间是无限的，当池子满了就不在添加线程了；如果池中的所有线程均在繁忙状态，对于新任务会进入阻塞队列中(无界的阻塞队列)
适用：执行长期的任务，性能好很多

newSingleThreadExecutor:

底层：FinalizableDelegatedExecutorService包装的ThreadPoolExecutor实例，corePoolSize为1；maximumPoolSize为1；keepAliveTime为0L；unit为：TimeUnit.MILLISECONDS；workQueue为：new LinkedBlockingQueue() 无解阻塞队列
通俗：创建只有一个线程的线程池，且线程的存活时间是无限的；当该线程正繁忙时，对于新任务会进入阻塞队列中(无界的阻塞队列)
适用：一个任务一个任务执行的场景

NewScheduledThreadPool:

底层：创建ScheduledThreadPoolExecutor实例，corePoolSize为传递来的参数，maximumPoolSize为Integer.MAX_VALUE；keepAliveTime为0；unit为：TimeUnit.NANOSECONDS；workQueue为：new DelayedWorkQueue() 一个按超时时间升序排序的队列
通俗：创建一个固定大小的线程池，线程池内线程存活时间无限制，线程池可以支持定时及周期性任务执行，如果所有线程均处于繁忙状态，对于新任务会进入DelayedWorkQueue队列中，这是一种按照超时时间排序的队列结构
适用：周期性执行任务的场景

    设计模式：大佬们针对典型场景设计出来的解决方案
    
    
    单例模式：设计模式的一种，一个对象只能被实例化一次(一个类只能实例化出一个对象)，资源只能被加载一次
    
    单利模式的实现：
        饿汉模式：资源在程序初始化时一次性全部加载（初始化时实例对象）
            
        懒汉模式：资源在使用时加载，对象在使用时再实例化
        
        
    锁的种类特性及使用场景：
    互斥锁：mutex，用于保证在任何时刻，都只能有一个线程访问该对象。当获取锁操作失败时，线程会进入睡眠，等待锁释放时被唤醒 

    自旋锁：spinlock，在任何时刻同样只能有一个线程访问对象。但是当获取锁操作失败时，不会进入睡眠，而是会在原地自旋，直到锁被释放。这样节省了线程从睡眠状态到被唤醒期间的消耗，在加锁时间短暂的环境下会极大的提高效率。但如果加锁时间过长，则会非常浪费CPU资源 

    读写锁：rwlock，区分读和写，处于读操作时，可以允许多个线程同时获得读操作。但是同一时刻只能有一个线程可以获得写锁。其它获取写锁失败的线程都会进入睡眠状态，直到写锁释放时被唤醒。 
    注意：写锁会阻塞其它读写锁。当有一个线程获得写锁在写时，读锁也不能被其它线程获取；写优先于读，当有线程因为等待写锁而进入睡眠时，则后续读者也必须等待 
    适用于读取数据的频率远远大于写数据的频率的场合。 

    RCU：即read-copy-update，在修改数据时，首先需要读取数据，然后生成一个副本，对副本进行修改。修改完成后，再将老数据update成新的数据。使用RCU时，读者几乎不需要同步开销，既不需要获得锁，也不使用原子指令，不会导致锁竞争，因此就不用考虑死锁问题了。而对于写者的同步开销较大，它需要复制被修改的数据，还必须使用锁机制同步并行其它写者的修改操作。在有大量读操作，少量写操作的情况下效率非常高 

    信号量：semaphore，是用于线程间同步的，当一个线程完成操作后就通过信号量通知其它线程，然后别的线程就可以继续进行某些操作了。 

    信号量和互斥锁的区别：semaphore

    1、信号量是用于线程间同步的，而互斥锁是用于线程的互斥的
    2、互斥量的获取和释放都是在同一线程中完成的，pthread_mutex_lock(),pthread_mutex_unlock()。而信号量的获得和释放是在不同的线程的操作为sem_wait(),sempost()；
    3、互斥量的值只能为0和1，而信号量只要value>0，其它线程就可以sem_wait成功，成功后信号量value减一。若value值不大于0，则sem_wait阻塞，直到sem_post释放后value加1。因此信号量的值可以为非负整数