【Linux】-多线程的知识都收尾(线程池,封装的线程,单例模式,自旋锁)

💖作者:小树苗渴望变成参天大树🎈

🎉作者宣言:认真写好每一篇博客💤

🎊作者gitee:gitee

💞作者专栏:C语言,数据结构初阶,Linux,C++ 动态规划算法🎄
如 果 你 喜 欢 作 者 的 文 章 ,就 给 作 者 点 点 关 注 吧!

文章目录


前言

今天我们讲解线程的收尾工作,前面博主花了很长时间给大家讲解线程,确实线程这部分要将的东西太多了,大家把前面的掌握好了就不容易了,这篇博主要讲解的是带大家写一个线程池,还有一些c++中带线程,话不多说,我们开始进入正文的讲解。


提示:以下是本篇文章正文内容,下面案例可供参考

一、线程池

大家还记得我写的进程池代码吗??我们当初实现的进程池,是通过父进程创建多个子进程,父进程给子进程派发任务,子进程处理数据,那我们的线程池也是这样去做的,当时线程池比进程池要麻烦一点,他要多数据进行保护,接下来直接看代码,里面有注释:任务还是之前写的计算器任务。
ThreadPool.hpp:

cpp 复制代码
#include<iostream>
#include<pthread.h>
#include<vector>
#include<queue>
using namespace std;

struct ThreadInfo
{
    string threadname;
    pthread_t threadid;
};

template<class T>
class ThreadPool
{
    const static int num=3;//线程信息数组的默认容量,也就是线程数亩
public:
    void lock(pthread_mutex_t* lock)
    {
        pthread_mutex_lock(lock);
    }
    void unlock(pthread_mutex_t* lock)
    {
        pthread_mutex_unlock(lock);
    }
    void wait(pthread_cond_t* cond,pthread_mutex_t*lock)
    {
        pthread_cond_wait(cond,lock);
    }

    void signal(pthread_cond_t* cond)
    {
        pthread_cond_signal(cond);
    }

    string getThreadName(pthread_t tid1)//通过获取线程自己的tid,在线程信息数组找匹配的线程名
    {
        string name;
        for(const auto & tid:threadinfo_)
        {
            if(tid.threadid==tid1)
            {
               return tid.threadname;
            }
        }
        return "None";
    }

    bool IsEmpty()
    {
        return tasks_.empty();
    }
public:
    ThreadPool(int threadcap=num):threadinfo_(num)
    {
        //给互斥锁和条件变量进行初始化
        pthread_mutex_init(&lock_,NULL);
        pthread_cond_init(&cond_,NULL);
    }

   static void* threadfunc(void* arg)//因为线程执行的函数必须是一个参数,不用静态的,就会有一个隐藏的this,但有需要this来调用,所以创建线程的时候就直接将this传进来。
    {
        ThreadPool<T>* tp=static_cast<ThreadPool<T>*>(arg);
        string name=tp->getThreadName(pthread_self());
        while(true)
        {
            tp->lock(&tp->lock_);
            while(tp->IsEmpty())
            {
                tp->wait(&tp->cond_,&tp->lock_);
            }
            T task=tp->pop();
            tp->unlock(&tp->lock_);

            task();//处理任务,线程拿到任务就是自己的,所以不需要在加锁里面。


            cout<<name<<" is working on task: "<<task.GetTask()<<endl;

        }

    }
    void start()//启动线程(创建线程)
    {
        for(int i=0;i<threadinfo_.size();i++)//这个线程数初始化的时候就定好了,所以存放线程信息的数组大小也提前开辟好
        {
            threadinfo_[i].threadname="thread"+to_string(i);
            pthread_create(&(threadinfo_[i].threadid),NULL,threadfunc,this);
        }
    }
    T pop()//获取队列中的任务
    {
        T t=tasks_.front();
        tasks_.pop();
        return t;
    }
   void push(const T& task)
    {
        //加锁的目的让队列只能有一个线程访问,我主线程发任务你其他线程先等着,不然我放一办你就读取,读到的数据不完整
        lock(&lock_);
        tasks_.push(task);
        signal(&cond_);//当主线程发布一个任务后,任务队列肯定不为空,就可以唤醒线程来处理了
        unlock(&lock_);
    }
    ~ThreadPool()
    {
        pthread_mutex_destroy(&lock_);
        pthread_cond_destroy(&cond_);
    }
private:
    vector<ThreadInfo> threadinfo_;//存储创建的每个线程(处理主线程发来任务的线程)信息的数组
    queue<T> tasks_;//存放主线程发来任务的队列

    pthread_mutex_t lock_;//用于处理任务线程直接的互斥和同步
    pthread_cond_t cond_;//条件变量
};

main.cc:

cpp 复制代码
#include"ThreadPool.hpp"
#include<ctime>
#include<unistd.h>
#include"task.hpp"
int main()
{
    cout<<"main start"<<endl;
    ThreadPool<Task>* tp=new ThreadPool<Task>(3);
    srand(time(nullptr)^getpid());
    tp->start();//启动线程池
    while(true)
    {
        int x=rand()%10+1;
        int y=rand()%10;
        char op=opers[rand()%opers.size()];

        Task t(x,y,op);//创建任务

        tp->push(t);//提交任务,其余的处理就让线程池去做吧
        
        sleep(1);
        cout<<"result:"<<t.GetResult()<<endl;
        
    }

    return 0;
}

此线程池一秒往线程里面发布一个任务,而线程需要实现同步互斥,所以结果会看到他们按照顺序来执行主线程发布的任务。

二、单例模式

之前在C++的博客中写过单例模式

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

单例模式的特点

某些类, 只应该具有一个对象(实例), 就称之为单例.

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

单例通常有两种设计模式,一种是俄汉,一种是懒汉,今天以懒汉为例:

懒汉方式实现单例模式(线程安全版本)

我们将刚才的线程池改成懒汉模式:

ThreadPooldanli.hpp:

cpp 复制代码
#include<iostream>
#include<pthread.h>
#include<vector>
#include<queue>
using namespace std;

struct ThreadInfo
{
    string threadname;
    pthread_t threadid;
};

template<class T>
class ThreadPool
{
    const static int num=3;//线程的默认容量
public:
    void lock(pthread_mutex_t* lock)
    {
        pthread_mutex_lock(lock);
    }
    void unlock(pthread_mutex_t* lock)
    {
        pthread_mutex_unlock(lock);
    }
    void wait(pthread_cond_t* cond,pthread_mutex_t*lock)
    {
        pthread_cond_wait(cond,lock);
    }

    void signal(pthread_cond_t* cond)
    {
        pthread_cond_signal(cond);
    }

    string getThreadName(pthread_t tid1)
    {
        string name;
        for(const auto & tid:threadinfo_)
        {
            if(tid.threadid==tid1)
            {
               return tid.threadname;
            }
        }
        return "None";
    }

    bool IsEmpty()
    {
        return tasks_.empty();
    }
public:
   static void* threadfunc(void* arg)
    {
        ThreadPool<T>* tp=static_cast<ThreadPool<T>*>(arg);
        string name=tp->getThreadName(pthread_self());
        while(true)
        {
            tp->lock(&tp->lock_);
            while(tp->IsEmpty())
            {
                tp->wait(&tp->cond_,&tp->lock_);
            }
            T task=tp->pop();
            tp->unlock(&tp->lock_);
            task();
            cout<<name<<" is working on task: "<<task.GetTask()<<endl;

        }
    }
    void start()//启动线程(创建线程)
    {
        for(int i=0;i<threadinfo_.size();i++)
        {
            threadinfo_[i].threadname="thread"+to_string(i);
            pthread_create(&(threadinfo_[i].threadid),NULL,threadfunc,this);
        }
    }
    T pop()
    {
        T t=tasks_.front();
        tasks_.pop();
        return t;
    }
   void push(const T& task)
    {
        lock(&lock_);
        tasks_.push(task);
        signal(&cond_);
        unlock(&lock_);
    }


   static ThreadPool<T>* getInstance()//对外提供单例对象接口,必须静态的,才能使用类名去调用
    {
        if(nullptr==instance_)//双重检查,第一次申请锁后,创建对象,后面的线程连第一个判断就进不去,就不会每个线程都会有申请锁释放锁的过程,增加效率。
        {
            pthread_mutex_lock(&mutex_);
            if(nullptr==instance_)
            {
                instance_=new ThreadPool<T>();
            }
            pthread_mutex_unlock(&mutex_);
        }
        return instance_;
    }

   //防拷贝
    ThreadPool(const ThreadPool&)=delete;
    const ThreadPool& operator=(const ThreadPool&)=delete;
private://将构造函数私有化,就创建不了对象了。
     ThreadPool(int threadcap=num):threadinfo_(num)
    {
        //给互斥锁和条件变量进行初始化
        pthread_mutex_init(&lock_,NULL);
        pthread_cond_init(&cond_,NULL);
    }
     ~ThreadPool()
    {
        pthread_mutex_destroy(&lock_);
        pthread_cond_destroy(&cond_);
    }
private:
    vector<ThreadInfo> threadinfo_;//存储每个线程信息的数组
    queue<T> tasks_;//存放主线程发来任务的队列

    pthread_mutex_t lock_;//互斥锁
    pthread_cond_t cond_;//条件变量
    
    static ThreadPool<T>* instance_;//定一个懒汉的单例对象,不能是栈区的变量,会套娃
    static pthread_mutex_t mutex_;//防止多线程同时创建对象,在刚判断完为不为空的时候,被切走,下次进来直接创建对象,这样就不止一个对象了
};

template<class T>
ThreadPool<T>* ThreadPool<T>::instance_=nullptr;//给单利对象进行初始化

template<class T>
pthread_mutex_t ThreadPool<T>::mutex_=PTHREAD_MUTEX_INITIALIZER;//初始化互斥锁

maindanli.cc:

cpp 复制代码
#include"ThreadPooldanli.hpp"
#include<ctime>
#include<unistd.h>
#include"task.hpp"
int main()
{
    cout<<"main start"<<endl;
    
    srand(time(nullptr)^getpid());
    ThreadPool<Task>::getInstance()->start();//启动线程池
    while(true)
    {
        int x=rand()%10+1;
        int y=rand()%10;
        char op=opers[rand()%opers.size()];

        Task t(x,y,op);//创建任务

         ThreadPool<Task>::getInstance()->push(t);//提交任务
            sleep(1);
        cout<<"result:"<<t.GetResult()<<endl;
        
    }

    return 0;
}

效果和刚才的一样的。

最重要的代码:

cpp 复制代码
 static ThreadPool<T>* getInstance()//对外提供单例对象接口,必须静态的,才能使用类名去调用
    {
        if(nullptr==instance_)//双重检查,第一次申请锁后,创建对象,后面的线程连第一个判断就进不去,就不会每个线程都会有申请锁释放锁的过程,增加效率。
        {
            pthread_mutex_lock(&mutex_);
            if(nullptr==instance_)
            {
                instance_=new ThreadPool<T>();
            }
            pthread_mutex_unlock(&mutex_);
        }
        return instance_;
    }

三、STL,智能指针和线程安全

STL中的容器是否是线程安全的?

不是.

原因是, STL 的设计初衷是将性能挖掘到极致, 而一旦涉及到加锁保证线程安全, 会对性能造成巨大的影响.而且对于不同的容器, 加锁方式的不同, 性能可能也不同(例如hash表的锁表和锁桶).因此 STL 默认不是线程安全. 如果需要在多线程环境下使用, 往往需要调用者自行保证线程安全.
智能指针是否是线程安全的?

对于 unique_ptr, 由于只是在当前代码块范围内生效, 因此不涉及线程安全问题.对于 shared_ptr, 多个对象需要共用一个引用计数变量, 所以会存在线程安全问题. 但是标准库实现的时候考虑到了这个问题, 基于原子操作(CAS)的方式保证 shared_ptr 能够高效, 原子的操作引用计数/

四、其他常见的各种锁

悲观锁 :在每次取数据时,总是担心数据会被其他线程修改,所以会在取数据前先加锁(读锁,写锁,行锁等),当其他线程想要访问数据时,被阻塞挂起。
乐观锁 :每次取数据时候,总是乐观的认为数据不会被其他线程修改,因此不上锁。但是在更新数据前,会判断其他数据在更新前有没有对数据进行修改。主要采用两种方式:版本号机制和CAS操作。
CAS操作 :当需要更新数据时,判断当前内存值和之前取得的值是否相等。如果相等则用新值更新。若不等则失败,失败则重试,一般是一个自旋的过程,即不断重试。
自旋锁: 自旋锁适用于访问临界区时间短的。我们之前使用的锁只要申请失败就被挂起了,等释放后,唤醒在去竞争锁,挂起于欧唤醒浪费时间,自旋锁是一只申请,申请失败还申请,直到申请成功,当一个线程拿到锁,访问临界资源的时间过长,还不如让他挂起,频繁去申请锁不好,所以自旋锁适用于访问临界资源时间少的场景。(trylock函数)

这两个就是自旋锁加锁的方式,第一个是阻塞,第二个是非阻塞,为什么还阻塞呢?原因是他申请不到锁会一直申请,在用户看来是被阻塞住了,非阻塞的意思是,申请失败就返回,没有阻塞效果。

五、总结

到这里我们的多线程部分就讲解到这里,也宣告我们系统部分就讲解到这里了,后面博主贵更新网络相关的知识,就是可以通过网络来获取数据来,让代码变得好玩起来了,我们这票就到这里了,我们下篇再见。

相关推荐
会掉头发3 分钟前
Linux进程通信之共享内存
linux·运维·共享内存·进程通信
我言秋日胜春朝★5 分钟前
【Linux】冯诺依曼体系、再谈操作系统
linux·运维·服务器
饮啦冰美式37 分钟前
22.04Ubuntu---ROS2使用rclcpp编写节点
linux·运维·ubuntu
wowocpp37 分钟前
ubuntu 22.04 server 安装 和 初始化 LTS
linux·运维·ubuntu
Huaqiwill38 分钟前
Ubuntun搭建并行计算环境
linux·云计算
wclass-zhengge41 分钟前
Netty篇(入门编程)
java·linux·服务器
Lign1731442 分钟前
ubuntu unrar解压 中文文件名异常问题解决
linux·运维·ubuntu
vip4511 小时前
Linux 经典面试八股文
linux
大霞上仙1 小时前
Ubuntu系统电脑没有WiFi适配器
linux·运维·电脑