• Linux 线程池&单例模式&读写锁&自旋锁

                     

           历经整整一个月终于到linux系统知识的最后一篇博客了，在这期间博主承认有偷懒几天~这篇博客写完后，接下来就是C++的高阶数据结构了。等博主把网络编程和MySql学好之后再继续写~今天主要介绍线程池、单例模式、读者写者模型、悲观锁和自旋锁的区别。

    目录

    线程池

    为什么要有线程池？

    代码测试

    thread_pool.hpp

    task.hpp

    main.cc

    Makefile

    单例模式

    什么是单例模式？

    什么是设计模式？

    单例模式特点

    饿汉实现方式和懒汉实现方式

    饿汉模式实现单例

    懒汉模式方式单例模式

    懒汉模式实现线程池版本代码

    signal_pool.hpp

    task.hpp

    main.cc

    读者写者模型

    基本理论

    函数接口 

    pthread_rwlock_init

    pthread_rwlock_destroy

    pthread_rwlock_wrlock

    pthread_rwlock_rdlock

    phread_rwlock_unlock

    如何理解？伪代码

    挂起等待的锁 vs 自旋锁

    自旋锁函数接口

    pthread_spin_init

    pthread_spin_destroy

    pthread_spin_lock

    pthread_spin_unlock

    线程池

    为什么要有线程池？

    我们先类比一下内存池：

           我们如果频繁向OS申请小块空间，OS就要在底层做很多动作，比如进程身份状态的变化，OS执行内存处理算法。这些对于用户层来说都是没必要的，但确实是耗时间的！所以引入了内存池的概念，趁着OS好的时候，一次申请一大块空间，这块空间在用户层进行管理，这样当我们再次申请空间时，就不需要向OS去要了，直接在用户层拿就好了，这样效率大大提高。

    再来看线程池：

           我们发现当多个任务到来时，OS要创建线程，但是临时创建的话效率肯定是比较低的。所以要提前创建好线程，保存在在线程池中。

    代码测试

    thread_pool.hpp

    1. #pragma once
    2.  
    3. #include<iostream>
    4. #include<pthread.h>
    5. #include<queue>
    6. #include<string>
    7. using namespace std;
    8.  
    9. namespace ns_threadpool
    10. {
    11.     const int g_num = 3; //线程池中线程的数目
    12.  
    13.     template<class T>
    14.     class ThreadPool
    15.     {
    16.     private:
    17.         int _num; //线程池中线程的数目
    18.         queue<T> _task_queue;//该成员是一个临界资源
    19.  
    20.         pthread_mutex_t _mtx;
    21.         pthread_cond_t _cond;
    22.  
    23.     public:
    24.         void Lock()
    25.         {
    26.             pthread_mutex_lock(&_mtx);
    27.         }
    28.         void Unlock()
    29.         {
    30.             pthread_mutex_unlock(&_mtx);
    31.         }
    32.         void Wait()
    33.         {
    34.             pthread_cond_wait(&_cond, &_mtx);
    35.         }
    36.         void WakeUp()
    37.         {
    38.             pthread_cond_signal(&_cond);
    39.         }
    40.         bool IsEmpty()
    41.         {
    42.             return _task_queue.empty();
    43.         }
    44.     public:
    45.         ThreadPool(int num = g_num)
    46.             :_num(num)
    47.         {
    48.             pthread_mutex_init(&_mtx, nullptr);
    49.             pthread_cond_init(&_cond, nullptr);
    50.         }
    51.  
    52.         //在类中要让线程执行类内成员方法(参数个数匹配问题,只有一个参数)，是不可行的！
    53.         //必须让线程执行静态方法
    54.         static void* Rountine(void* args)
    55.         {
    56.             pthread_detach(pthread_self());//线程分离
    57.             ThreadPool<T>* tp = (ThreadPool<T>*)args;
    58.  
    59.             while(true)
    60.             {
    61.                 tp->Lock();
    62.                 while(tp->IsEmpty())
    63.                 {
    64.                     //任务队列为空，线程该做些什么呢？
    65.                     tp->Wait();
    66.                 }
    67.                 //到这里，该任务队列中一定有任务了
    68.                 T t;
    69.                 tp->PopTask(&t);
    70.                 tp->Unlock();
    71.  
    72.                 t();
    73.             }
    74.         }
    75.         void InitThreadPool()
    76.         {
    77.             pthread_t tid;
    78.             for(int i = 0; i < _num; i++)
    79.             {
    80.                 pthread_create(&tid, nullptr, Rountine, (void*)this);
    81.             }
    82.         }
    83.  
    84.         void PushTask(const T& in)
    85.         {
    86.             Lock();
    87.             _task_queue.push(in);
    88.             Unlock();
    89.             WakeUp();
    90.         }
    91.         //由于queue大小可以动态增长，这里不考虑满了就等待的的情况
    92.  
    93.          //这里不能加锁，否则就成死锁了，Rountine也有锁,但是这里也是安全的~
    94.         void PopTask(T* out)
    95.         {
    96.             *out = _task_queue.front();//尾插头出
    97.             _task_queue.pop(); //尾插头出
    98.         }
    99.         ~ThreadPool()
    100.         {
    101.             pthread_mutex_destroy(&_mtx);
    102.             pthread_cond_destroy(&_cond);
    103.         }
    104.     };
    105. }

    task.hpp

    1. #pragma once
    2. #include <iostream>
    3. #include <pthread.h>
    4. #include<map>
    5. #include<functional>
    6. namespace ns_task
    7. {
    8.     class Task
    9.     {
    10.     public:
    11.         Task()
    12.         {}
    13.         Task(int x, int y, char op)
    14.             : _x(x), _y(y), _op(op)
    15.         {}
    16.         int Run()
    17.         {
    18.             int res = 0;
    19.             switch (_op)
    20.             {
    21.             case '+':
    22.                 res = _x + _y;
    23.                 break;
    24.             case '-':
    25.                 res = _x - _y;
    26.                 break;
    27.             case '*':
    28.                 res = _x * _y;
    29.                 break;
    30.             case '/':
    31.                 res = _x / _y;
    32.                 break;
    33.             case '%':
    34.                 res = _x % _y;
    35.                 break;
    36.             default:
    37.                 cout << "bug??" << endl;
    38.                 break;
    39.             }
    40.             cout << "当前任务正在被: " << pthread_self() << " 处理: ";
    41.             cout << _x << _op << _y << "=" << res << endl;
    42.             return res;
    43.         }
    44.         int operator()()
    45.         {
    46.             return Run();
    47.         }
    48.  
    49.     private:
    50.         int _x;
    51.         int _y;
    52.         char _op; //+-*/%
    53.     };
    54. }

    main.cc

    1. #include "thread_pool.hpp"
    2. #include "task.hpp"
    3.  
    4. #include<time.h>
    5. #include<stdlib.h>
    6. #include<unistd.h>
    7.  
    8. using namespace ns_task;
    9. using namespace ns_threadpool;
    10.  
    11. int main()
    12. {
    13.     ThreadPool<Task>* tp = new ThreadPool<Task>(3);
    14.     tp->InitThreadPool();
    15.     srand((unsigned int)time(0));
    16.  
    17.     while(true)
    18.     {
    19.         //生产任务
    20.         int x = rand()%20 + 1;
    21.         int y = rand()%10 + 1;
    22.         char op = "+-*/%"[rand()%5];
    23.         Task t(x, y, op);
    24.  
    25.         //放任务
    26.         tp->PushTask(t);
    27.         sleep(1);
    28.     }
    29.     return 0;
    30. }

    Makefile

    1. main:main.cc
    2. 	g++ -o $@ $^ -std=c++11 -lpthread
    3. .PHONY:clean
    4. clean:
    5. 	rm -f main

    测试结果：

    这时候我们发现，我们不断往任务队列中塞任务，我们在线程池中创建的多个线程不断去处理。 

    单例模式

    什么是单例模式？

    单例模式是一种 "经典的, 常用的, 常考的" 设计模式。

    什么是设计模式？

           IT行业这么火, 涌入的人很多. 俗话说林子大了啥鸟都有. 大佬和菜鸡们两极分化的越来越严重.。为了让菜鸡们不太拖大佬的后腿, 于是大佬们针对一些经典的常见的场景, 给定了一些对应的解决方案, 这个就是设计模式。

    单例模式特点

    某些类, 只应该具有一个对象(实例), 就称之为单例。
    例如一个男人只能有一个媳妇.
    在很多服务器开发场景中, 经常需要让服务器加载很多的数据 (上百G) 到内存中. 此时往往要用一个单例的类来管理这些数据。

    饿汉实现方式和懒汉实现方式

    洗完的例子：
    吃完饭, 立刻洗碗, 这种就是饿汉方式. 因为下一顿吃的时候可以立刻拿着碗就能吃饭。
    吃完饭, 先把碗放下, 然后下一顿饭用到这个碗了再洗碗, 就是懒汉方式。

    总结：懒汉方式最核心的思想是 "延时加载"，从而能够优化服务器的启动速度。这和我们之前讲过的内存申请和内存使用及写时拷贝的概念类似。

    饿汉模式实现单例

    懒汉模式方式单例模式

     通过Singleton 这个包装类来使用T对象, 则一个进程中只有一个T对象的实例。

    注意：

    存在一个严重的问题, 线程不安全。第一次调用 GetInstance 的时候, 如果两个线程同时调用, 可能会创建出两份 T 对象的实例。

    懒汉模式实现线程池版本代码

    signal_pool.hpp

    1. #pragma once
    2.  
    3. #include <iostream>
    4. #include <pthread.h>
    5. #include <queue>
    6. #include <string>
    7. using namespace std;
    8.  
    9. namespace ns_threadpool
    10. {
    11.     const int g_num = 3; //线程池中线程的数目
    12.  
    13.     template <class T>
    14.     class ThreadPool
    15.     {
    16.     private:
    17.         int _num;             //线程池中线程的数目
    18.         queue<T> _task_queue; //该成员是一个临界资源
    19.  
    20.         pthread_mutex_t _mtx;
    21.         pthread_cond_t _cond;
    22.  
    23.         static ThreadPool<T>* _ins;
    24.  
    25.     private:
    26.         //构造函数必须得实现，而且设置为私有
    27.         ThreadPool(int num = g_num)
    28.             : _num(num)
    29.         {
    30.             pthread_mutex_init(&_mtx, nullptr);
    31.             pthread_cond_init(&_cond, nullptr);
    32.         }
    33.         //拷贝构造和赋值设置为私有
    34.         ThreadPool(const ThreadPool<T>& tp) = delete;
    35.         ThreadPool<T> operator=(const ThreadPool<T>& tp) = delete;
    36.  
    37.     public:
    38.         static ThreadPool<T>* GetInstance()
    39.         {
    40.             //静态锁不用手动初始化和销毁
    41.             static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
    42.             //当前单例对象还没有被创建
    43.             if(_ins == nullptr) //双判定，减少锁的争用，提高单例的效率
    44.             {
    45.                 pthread_mutex_lock(&lock);
    46.                 if(_ins == nullptr)
    47.                 {
    48.                     _ins = new ThreadPool<T>();
    49.                     _ins->InitThreadPool(); //创建线程
    50.                     cout << "首次加载对象" << endl;
    51.                 }
    52.                 pthread_mutex_unlock(&lock);
    53.             }
    54.             return _ins;
    55.         }
    56.         //在类中要让线程执行类内成员方法(参数个数匹配问题,只有一个参数)，是不可行的！
    57.         //必须让线程执行静态方法
    58.         static void *Rountine(void *args)
    59.         {
    60.             pthread_detach(pthread_self()); //线程分离
    61.             ThreadPool<T> *tp = (ThreadPool<T> *)args;
    62.  
    63.             while (true)
    64.             {
    65.                 tp->Lock();
    66.                 while (tp->IsEmpty())
    67.                 {
    68.                     //任务队列为空，线程该做些什么呢？
    69.                     tp->Wait();
    70.                 }
    71.                 //到这里，该任务队列中一定有任务了
    72.                 T t;
    73.                 tp->PopTask(&t);
    74.                 tp->Unlock();
    75.  
    76.                 t();
    77.             }
    78.         }
    79.         void InitThreadPool()
    80.         {
    81.             pthread_t tid;
    82.             for (int i = 0; i < _num; i++)
    83.             {
    84.                 pthread_create(&tid, nullptr, Rountine, (void *)this);
    85.             }
    86.         }
    87.  
    88.         void PushTask(const T& in)
    89.         {
    90.             Lock();
    91.             _task_queue.push(in);
    92.             Unlock();
    93.             WakeUp();
    94.         }
    95.         //由于queue大小可以动态增长，这里不考虑满了就等待的的情况
    96.  
    97.         //这里不能加锁，否则就成死锁了，Rountine也有锁,但是这里也是安全的~
    98.         void PopTask(T *out)
    99.         {
    100.             *out = _task_queue.front(); //尾插头出
    101.             _task_queue.pop();          //尾插头出
    102.         }
    103.         ~ThreadPool()
    104.         {
    105.             pthread_mutex_destroy(&_mtx);
    106.             pthread_cond_destroy(&_cond);
    107.         }
    108.  
    109.     public:
    110.         void Lock()
    111.         {
    112.             pthread_mutex_lock(&_mtx);
    113.         }
    114.         void Unlock()
    115.         {
    116.             pthread_mutex_unlock(&_mtx);
    117.         }
    118.         void Wait()
    119.         {
    120.             pthread_cond_wait(&_cond, &_mtx);
    121.         }
    122.         void WakeUp()
    123.         {
    124.             pthread_cond_signal(&_cond);
    125.         }
    126.         bool IsEmpty()
    127.         {
    128.             return _task_queue.empty();
    129.         }
    130.     };
    131.  
    132.     template<class T>
    133.     ThreadPool<T>* ThreadPool<T>::_ins = nullptr;
    134. }

    task.hpp

    1. #pragma once
    2. #include <iostream>
    3. #include <pthread.h>
    4. #include<map>
    5. #include<functional>
    6. namespace ns_task
    7. {
    8.     class Task
    9.     {
    10.     public:
    11.         Task()
    12.         {}
    13.         Task(int x, int y, char op)
    14.             : _x(x), _y(y), _op(op)
    15.         {}
    16.         int Run()
    17.         {
    18.             int res = 0;
    19.             switch (_op)
    20.             {
    21.             case '+':
    22.                 res = _x + _y;
    23.                 break;
    24.             case '-':
    25.                 res = _x - _y;
    26.                 break;
    27.             case '*':
    28.                 res = _x * _y;
    29.                 break;
    30.             case '/':
    31.                 res = _x / _y;
    32.                 break;
    33.             case '%':
    34.                 res = _x % _y;
    35.                 break;
    36.             default:
    37.                 cout << "bug??" << endl;
    38.                 break;
    39.             }
    40.             cout << "当前任务正在被: " << pthread_self() << " 处理: ";
    41.             cout << _x << _op << _y << "=" << res << endl;
    42.             return res;
    43.         }
    44.         int operator()()
    45.         {
    46.             return Run();
    47.         }
    48.  
    49.     private:
    50.         int _x;
    51.         int _y;
    52.         char _op; //+-*/%
    53.     };
    54. }

    main.cc

    1. #include "thread_pool.hpp"
    2. #include "task.hpp"
    3.  
    4. #include<time.h>
    5. #include<stdlib.h>
    6. #include<unistd.h>
    7.  
    8. using namespace ns_task;
    9. using namespace ns_threadpool;
    10.  
    11. int main()
    12. {
    13.     cout << "当前正在运行我的进程其他代码..." << endl;
    14.     cout << "当前正在运行我的进程其他代码..." << endl;
    15.     cout << "当前正在运行我的进程其他代码..." << endl;
    16.     cout << "当前正在运行我的进程其他代码..." << endl;
    17.     cout << "当前正在运行我的进程其他代码..." << endl;
    18.     sleep(3);
    19.  
    20.     while(true)
    21.     {
    22.         //生产任务
    23.         int x = rand()%20 + 1;
    24.         int y = rand()%10 + 1;
    25.         char op = "+-*/%"[rand()%5];
    26.         Task t(x, y, op);
    27.         Task t1(rand()%20+1, rand()%10+1, "+-*/%"[rand()%5]);
    28.         
    29.         ThreadPool<Task>::GetInstance()->PushTask(t);
    30.         
    31.         //单例模式本身会在任何场景，任何环境下使用
    32.         //GetInstance():被多线程重入，进而导致线程安全问题
    33.         //所以要加锁
    34.         cout << ThreadPool<Task>::GetInstance() << endl;
    35.         sleep(1);
    36.     }
    37.     return 0;
    38. }

    运行结果：

    我们发现每次都是一个只有对象，这个对象的线程池里面有多个线程执行任务。

    读者写者模型

    基本理论

    函数接口 

    pthread_rwlock_init

    pthread_rwlock_t *restrict rwlock：传入定义的pthread_rwlock_t变量的地址 

    const pthread_rwlockattr_t *restrict attr：设置属性，我们不关心，传nullptr就好了

    pthread_rwlock_destroy

    pthread_rwlock_t* rwlock：传入变量的地址，进行释放锁资源 

    pthread_rwlock_wrlock

    以写方式加锁 

    pthread_rwlock_rdlock

    以读者身份加锁 

    phread_rwlock_unlock

    解锁，读者写者以统一方式解锁。

    如何理解？伪代码

    优先级

    读者优先：读者和写者同时到来的时候，我们让读者先进入访问。

    写者优先：当读者和写者同时到来的时候，比当前写者晚来的所有的读者，都不要进入临界区访问了，等临界区中没有读者的时候，让写者先写入。 

    注意：读者多，写着少的问题，是存在"饥饿问题"，但是，"饥饿问题"是一个中性词。

    挂起等待的锁 vs 自旋锁

    我们先找一个现实场景：

           对于临界资源任务处理时间比较短就不适合使用挂起等待的锁，因为可能还没有线程挂起等待，别的线程就释放锁了，这时候线程还得继续挂起然后立刻被唤醒，这是有一定成本的！ 

           如果对于处理任务比较长的时候，不适合自旋锁，自旋锁不停地循环检测锁的状态，长时间的话消耗CPU资源也是很大的。

    所以针对不同的场景，要选用合适的锁

    线程如何得知，自己在临界资源中呆多长时间？

    线程不知道！！程序员知道！所以是程序员选择锁的使用！

    自旋锁函数接口

    pthread_spin_init

    pthread_spinlock_t* lock：传入定义的自旋锁的变量的地址

    int pshared：是否进程间共享，我们一般设置成0

    pthread_spin_destroy

     pthread_spinlock_t* lock：传入定义的自旋锁的变量的地址，释放锁资源

    pthread_spin_lock

     pthread_spin_lock：传入定义的自旋锁的变量的地址，进行加锁

    pthread_spin_unlock

      pthread_spin_lock：传入定义的自旋锁的变量的地址，进行解锁

    我们发现自旋锁和互斥锁的使用几乎一模一样，有了之前的基础，我们就可以使用起来自旋锁。

    看到这里，给博主点个赞吧~

                            

  • 相关阅读:
    微服务(二) php laravel 用户客户端
    Tomcat服务器的简介
    springfox及springdoc
    YOLO目标检测——VOC2007数据集+已标注VOC格式标签下载分享
    Kafka3.2教程（一）消息队列与Kafka原理
    [科研琐事] 安装服务器的二三事
    失眠睡不着如何调理
    计算机毕业设计Java婚纱摄影网站(源码+系统+mysql数据库+lw文档)
    [2022 牛客多校2 E] Falfa with Substring (二项式反演 NTT)
    软件工程--软件过程学习笔记
  • 原文地址：https://blog.csdn.net/qq_58724706/article/details/125470866