手撕线程池

手撕线程池

代码

#include <assert.h>

#include <condition_variable>
#include <functional>
#include <memory>
#include <mutex>
#include <queue>
#include <thread>
#include <utility>
#include <vector>

typedef int size_t;

class ThreadPool {
 public:
  explicit ThreadPool(size_t threadcount = 8)
      : pool_(std::make_shared<Pool>()) {
    assert(threadcount);
    for (int i = 0; i < threadcount; i++) {
      std::thread([pool = pool_] {
        std::unique_lock<std::mutex> locker(pool->mtx);  // 先上锁
        for (;;) {
          if (pool->tasks.empty()) {
            continue;
          }
          auto task = std::move(pool->tasks.front());
          pool->tasks.pop();
          locker.unlock();
          task();
          locker.lock();
          if (pool->IsColsed) {
            break;
          } else {
            pool->cond.wait(locker);
          }
        }
      }).detach();
    }
  }

  ~ThreadPool() {
    assert(pool_);
    {
      std::lock_guard<std::mutex> locker(pool_->mtx);
      pool_->IsColsed = true;
    }
    pool_->cond.notify_all();
  }

  template <class T>
  void Addtask(T&& task) {
    {
      std::unique_lock<std::mutex> locker(pool_->cond);
      // 保证只有一个线程往里面放数据，而且保证放的时候没有人取
      pool_->tasks.emplace(std::forward<T>(task));
    }
    pool_->cond.notify_one();
  }

 private:
  struct Pool {
    bool IsColsed = false;
    std::mutex mtx;
    std::condition_variable cond;
    std::queue<std::function<void()>> tasks;
  };
  std::shared_ptr<Pool> pool_;
};

std::function

lambda和bind详解

这里可以看到什么是可调用对象

函数
函数指针
lambada表达式
std::bind()创建的对象，其实返回的就是一个可调用对象
重载括号运算符的类对象

那么为什么需要std::function

lambada表达式有自己唯一的类类型(未命名)

多个不同的可调用对象可能享有同样的调用形式

比如：

int add(int a,int b)

auto mod = [] (int a, int b) {}

这个时候add与mod同时享有同样的调用形式int (*)(int ,int)

这时候我们希望使用这些可调用对象构造一个简单的桌面计算器，这时候就需要定义一个函数表来存放这些可调用对象的指针，当需要某些特定操作的时候就可以拿出来用

map<string,int (int,int)> mp

但是这个时候就不能够加入mod,因为lambada表达式有自己的类类型，不匹配这时候就可以用std::function来解决

举例

std::function<int (int,int)> f 表示f是一个接收两个int返回一个int的可调用对象

这时候就要注意一点

就是不能直接将重载函数的函数名放进取，因为这会产生二义性，不过我们可以通过存放函数指针来巧妙的解决这个问题

std::forward

是用来保存原有参数类型进行参数传递的，返回的显示实参类型的右值引用

lock_guard与unique_lock的区别

lock_guard

更加的高效，是一种RAII的体现。
只能在析构函数中解锁。

unique_lock

更加的灵活，但是比 lock_guard 更消耗资源，可以自己随时 unlock 解锁

使用 condition_variable 的情况下必须使用unique_lock

condition_variable data_cond;
mutex mut;
{
	std::unique_lock<mutex>  lk(mut);
	data.wait(lk, func );
	// ...
	// ...
}

wait 会去检查这些条件，当条件 func 返回 true 时返回。如果条件不满足，func返回false，wait() 函数将解锁互斥量，并且将这个线程置于阻塞或等待状态。
以为在执行的过程中需要解锁 mutex， lock_guard 只能在析构函数中解锁，而unique_lock 可以unlock() 函数解锁。
link

互斥锁

一次只能一个线程拥有互斥锁，其他线程只有等待
互斥锁是在抢锁失败的情况下主动放弃CPU进入睡眠状态直到锁的状态改变时再唤醒，而操作系统负责
线程调度，为了实现锁的状态发生改变时唤醒阻塞的线程或者进程，需要把锁交给操作系统管理，所以
互斥锁在加锁操作时涉及上下文的切换。互斥锁实际的效率还是可以让人接受的，加锁的时间大概
100ns左右，而实际上互斥锁的一种可能的实现是先自旋一段时间，当自旋的时间超过阀值之后再将线
程投入睡眠中，因此在并发运算中使用互斥锁（每次占用锁的时间很短）的效果可能不亚于使用自旋锁

自旋锁

如果进线程无法取得锁，进线程不会立刻放弃CPU时间片，而是一直循环尝试获取锁，直到获取为止。
如果别的线程长时期占有锁，那么自旋就是在浪费CPU做无用功，但是自旋锁一般应用于加锁时间很短
的场景，这个时候效率比较高

信号量

1.系统首先要检测该资源的信号量；

2.若该资源的信号量值大于0，则进程可以使用该资源，此时，进程将该资源的信号量值减1；

3.若该资源的信号量值为0，则进程进入休眠状态，直到信号量值大于0时进程被唤醒，访问该资源；

当进程不再使用由一个信号量控制的共享资源时，该信号量值增加1，如果此时有进程处于休眠状态等待此信号量，则该进程会被唤醒。

信号量实现消费者生产者模型

/*
    信号量的类型 sem_t
    int sem_init(sem_t *sem, int pshared, unsigned int value);
        - 初始化信号量
        - 参数：
            - sem : 信号量变量的地址
            - pshared : 0 用在线程间 ，非0 用在进程间
            - value : 信号量中的值

    int sem_destroy(sem_t *sem);
        - 释放资源

    int sem_wait(sem_t *sem);
        - 对信号量加锁，调用一次对信号量的值-1，如果值为0，就阻塞

    int sem_trywait(sem_t *sem);

    int sem_timedwait(sem_t *sem, const struct timespec *abs_timeout);
    int sem_post(sem_t *sem);
        - 对信号量解锁，调用一次对信号量的值+1

    int sem_getvalue(sem_t *sem, int *sval);

    sem_t psem;
    sem_t csem;
    init(psem, 0, 8);
    init(csem, 0, 0);

    producer() {
        sem_wait(&psem);
        sem_post(&csem)
    }

    customer() {
        sem_wait(&csem);
        sem_post(&psem)
    }

*/

#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>
#include <semaphore.h>

// 创建一个互斥量
pthread_mutex_t mutex;
// 创建两个信号量
sem_t psem;
sem_t csem;

struct Node{
    int num;
    struct Node *next;
};

// 头结点
struct Node * head = NULL;

void * producer(void * arg) {

    // 不断的创建新的节点，添加到链表中
    while(1) {
        sem_wait(&psem);
        pthread_mutex_lock(&mutex);
        struct Node * newNode = (struct Node *)malloc(sizeof(struct Node));
        newNode->next = head;
        head = newNode;
        newNode->num = rand() % 1000;
        printf("add node, num : %d, tid : %ld\n", newNode->num, pthread_self());
        pthread_mutex_unlock(&mutex);
        sem_post(&csem);
    }

    return NULL;
}

void * customer(void * arg) {

    while(1) {
        sem_wait(&csem);
        pthread_mutex_lock(&mutex);
        // 保存头结点的指针
        struct Node * tmp = head;
        head = head->next;
        printf("del node, num : %d, tid : %ld\n", tmp->num, pthread_self());
        free(tmp);
        pthread_mutex_unlock(&mutex);
        sem_post(&psem);
       
    }
    return  NULL;
}

int main() {

    pthread_mutex_init(&mutex, NULL);
    sem_init(&psem, 0, 8);
    sem_init(&csem, 0, 0);

    // 创建5个生产者线程，和5个消费者线程
    pthread_t ptids[5], ctids[5];

    for(int i = 0; i < 5; i++) {
        pthread_create(&ptids[i], NULL, producer, NULL);
        pthread_create(&ctids[i], NULL, customer, NULL);
    }

    for(int i = 0; i < 5; i++) {
        pthread_detach(ptids[i]);
        pthread_detach(ctids[i]);
    }

    while(1) {
        sleep(10);
    }

    pthread_mutex_destroy(&mutex);

    pthread_exit(NULL);

    return 0;
}