类模板 函数指针 function函数 bind，线程池 lambda函数的使用

最新推荐文章于 2023-05-29 18:06:21 发布
最新推荐文章于 2023-05-29 18:06:21 发布
阅读量509 收藏 2
点赞数 1
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_19272431/article/details/78582335
版权

类模板

考虑我们写一个简单的栈的类，这个栈可以支持int类型，long类型，string类型等等，不利用类模板，我们就要写三个以上的stack类，其中代码基本一样，通过类模板，我们可以定义一个简单的栈模板，再根据需要实例化为int栈，long栈，string栈。

复制代码 
//statck.h
template <class T> class Stack {
    public:
        Stack();
        ~Stack();
        void push(T t);
        T pop();
        bool isEmpty();
    private:
        T *m_pT;        
        int m_maxSize;
        int m_size;
};

#include "stack.cpp"
复制代码

 

复制代码 
//stack.cpp
template <class  T>  Stack<T>::Stack(){
   m_maxSize = 100;      
   m_size = 0;
   m_pT = new T[m_maxSize];
}
template <class T>  Stack<T>::~Stack() {
   delete [] m_pT ;
}
        
template <class T> void Stack<T>::push(T t) {
    m_size++;
    m_pT[m_size - 1] = t;
    
}
template <class T> T Stack<T>::pop() {
    T t = m_pT[m_size - 1];
    m_size--;
    return t;
}
template <class T> bool Stack<T>::isEmpty() {
    return m_size == 0;
}
复制代码

上述定义了一个类模板--栈，这个栈很简单，只是为了说明类模板如何使用而已，最多只能支持100个元素入栈，使用示例如下:

复制代码 
//main.cpp
#include <stdio.h>
#include "stack.h"
int main() {
    Stack<int> intStack;
    intStack.push(1);
    intStack.push(2);
    intStack.push(3);
    
    while (!intStack.isEmpty()) {
        printf("num:%d\n", intStack.pop());
    }
    return 0;
}
复制代码

模板参数
模板可以有类型参数，也可以有常规的类型参数int，也可以有默认模板参数，例如

template<class T, T def_val> class Stack{...}

上述类模板的栈有一个限制，就是最多只能支持100个元素，我们可以使用模板参数配置这个栈的最大元素数,如果不配置，就设置默认最大值为100，代码如下:

复制代码 
//statck.h
template <class T,int maxsize = 100> class Stack {
    public:
        Stack();
        ~Stack();
        void push(T t);
        T pop();
        bool isEmpty();
    private:
        T *m_pT;        
        int m_maxSize;
        int m_size;
};

#include "stack.cpp"
复制代码

 

复制代码 
//stack.cpp
template <class T,int maxsize> Stack<T, maxsize>::Stack(){
   m_maxSize = maxsize;      
   m_size = 0;
   m_pT = new T[m_maxSize];
}
template <class T,int maxsize>  Stack<T, maxsize>::~Stack() {
   delete [] m_pT ;
}
        
template <class T,int maxsize> void Stack<T, maxsize>::push(T t) {
    m_size++;
    m_pT[m_size - 1] = t;
    
}
template <class T,int maxsize> T Stack<T, maxsize>::pop() {
    T t = m_pT[m_size - 1];
    m_size--;
    return t;
}
template <class T,int maxsize> bool Stack<T, maxsize>::isEmpty() {
    return m_size == 0;
}
复制代码

使用示例如下:

复制代码 
//main.cpp
#include <stdio.h>
#include "stack.h"
int main() {
    int maxsize = 1024;
    Stack<int,1024> intStack;
    for (int i = 0; i < maxsize; i++) {
        intStack.push(i);
    }
    while (!intStack.isEmpty()) {
        printf("num:%d\n", intStack.pop());
    }
    return 0;
}
复制代码

模板专门化

 当我们要定义模板的不同实现，我们可以使用模板的专门化。例如我们定义的stack类模板，如果是char*类型的栈，我们希望可以复制char的所有数据到stack类中，因为只是保存char指针，char指针指向的内存有可能会失效，stack弹出的堆栈元素char指针，指向的内存可能已经无效了。还有我们定义的swap函数模板，在vector或者list等容器类型时，如果容器保存的对象很大，会占用大量内存，性能下降，因为要产生一个临时的大对象保存a，这些都需要模板的专门化才能解决。

函数模板专门化

  假设我们swap函数要处理一个情况，我们有两个很多元素的vector<int>,在使用原来的swap函数，执行tmpT = t1要拷贝t1的全部元素，占用大量内存，造成性能下降，于是我们系统通过vector.swap函数解决这个问题,代码如下:

//method.h
template<class T> void swap(T& t1, T& t2);

#include "method.cpp"

 

复制代码 
#include <vector>
using namespace std;
template<class T> void swap(T& t1, T& t2) {
    T tmpT;
    tmpT = t1;
    t1 = t2;
    t2 = tmpT;
}

template<> void swap(std::vector<int>& t1, std::vector<int>& t2) {
    t1.swap(t2);
}
复制代码

template<>前缀表示这是一个专门化,描述时不用模板参数，使用示例如下:

复制代码 
//main.cpp
#include <stdio.h>
#include <vector>
#include <string>
#include "method.h"
int main() {
    using namespace std;
    //模板方法 
    string str1 = "1", str2 = "2";
    swap(str1, str2);
    printf("str1:%s, str2:%s\n", str1.c_str(), str2.c_str());  
    
    vector<int> v1, v2;
    v1.push_back(1);
    v2.push_back(2);
    swap(v1, v2);
    for (int i = 0; i < v1.size(); i++) {
        printf("v1[%d]:%d\n", i, v1[i]);
    }
    for (int i = 0; i < v2.size(); i++) {
        printf("v2[%d]:%d\n", i, v2[i]);
    }
    return 0;
}
复制代码

vector<int>的swap代码还是比较局限，如果要用模板专门化解决所有vector的swap，该如何做呢，只需要把下面代码

template<> void swap(std::vector<int>& t1, std::vector<int>& t2) {
    t1.swap(t2);
}
改为
template<class V> void swap(std::vector<V>& t1, std::vector<V>& t2) {
    t1.swap(t2);
}

就可以了，其他代码不变。

类模板专门化

 请看下面compare代码:

复制代码 
//compare.h
template <class T>
 class compare
 {
  public:
  bool equal(T t1, T t2)
  {
       return t1 == t2;
  }
};
复制代码

 

复制代码 
#include <iostream>
#include "compare.h"
 int main()
 {
  using namespace std;
  char str1[] = "Hello";
  char str2[] = "Hello";
  compare<int> c1;
  compare<char *> c2;   
  cout << c1.equal(1, 1) << endl;        //比较两个int类型的参数
  cout << c2.equal(str1, str2) << endl;   //比较两个char *类型的参数
  return 0;
 }
复制代码

在比较两个整数，compare的equal方法是正确的，但是compare的模板参数是char*时，这个模板就不能工作了，于是修改如下:

复制代码 
//compare.h
#include <string.h>
template <class T>
 class compare
 {
  public:
  bool equal(T t1, T t2)
  {
       return t1 == t2;
  }
};
   

template<>class compare<char *>  
{
public:
    bool equal(char* t1, char* t2)
    {
        return strcmp(t1, t2) == 0;
    }
};
复制代码

main.cpp文件不变，此代码可以正常工作。

模板类型转换

还记得我们自定义的Stack模板吗，在我们的程序中，假设我们定义了Shape和Circle类，代码如下:

//shape.h
class Shape {

};
class Circle : public Shape {
};

然后我们希望可以这么使用:

复制代码 
//main.cpp
#include <stdio.h>
#include "stack.h"
#include "shape.h"
int main() {
    Stack<Circle*> pcircleStack;
    Stack<Shape*> pshapeStack;
    pcircleStack.push(new Circle);
    pshapeStack = pcircleStack;
    return 0;
}
复制代码

这里是无法编译的，因为Stack<Shape*>不是Stack<Circle*>的父类，然而我们却希望代码可以这么工作，那我们就要定义转换运算符了，Stack代码如下:

复制代码 
//statck.h
template <class T> class Stack {
    public:
        Stack();
        ~Stack();
        void push(T t);
        T pop();
        bool isEmpty();
        template<class T2>  operator Stack<T2>();
    private:
        T *m_pT;        
        int m_maxSize;
        int m_size;
};

#include "stack.cpp"
复制代码

 

复制代码 
template <class  T>  Stack<T>::Stack(){
   m_maxSize = 100;      
   m_size = 0;
   m_pT = new T[m_maxSize];
}
template <class T>  Stack<T>::~Stack() {
   delete [] m_pT ;
}
        
template <class T> void Stack<T>::push(T t) {
    m_size++;
    m_pT[m_size - 1] = t;
    
}
template <class T> T Stack<T>::pop() {
    T t = m_pT[m_size - 1];
    m_size--;
    return t;
}
template <class T> bool Stack<T>::isEmpty() {
    return m_size == 0;
}

template <class T> template <class T2>  Stack<T>::operator Stack<T2>() {
    Stack<T2> StackT2;
    for (int i = 0; i < m_size; i++) {
        StackT2.push((T2)m_pT[m_size - 1]);
    }
    return StackT2;
}
复制代码

 

复制代码 
//main.cpp
#include <stdio.h>
#include "stack.h"
#include "shape.h"
int main() {
    Stack<Circle*> pcircleStack;
    Stack<Shape*> pshapeStack;
    pcircleStack.push(new Circle);
    pshapeStack = pcircleStack;
    return 0;
}
复制代码

这样，Stack<Circle>或者Stack<Circle*>就可以自动转换为Stack<Shape>或者Stack<Shape*>,如果转换的类型是Stack<int>到Stack<Shape>，编译器会报错。

其他

一个类没有模板参数，但是成员函数有模板参数，是可行的，代码如下:

复制代码 
class Util {
    public:
        template <class T> bool equal(T t1, T t2) {
            return t1 == t2;
        }
};

int main() {
    Util util;
    int a = 1, b = 2;
    util.equal<int>(1, 2);
    return 0;
}
复制代码

甚至可以把Util的equal声明为static,代码如下:

复制代码 
class Util {
    public:
         template <class T> static bool equal(T t1, T t2) {
            return t1 == t2;
        }
};

int main() {
    int a = 1, b = 2;
    Util::equal<int>(1, 2);
    return 0;
}

 function函数

1.仿函数:又叫std::function,是C++中的一个模板类

2.C语言中的函数指针:

int  add(int a,int b)

{

　　return a+b;

}

typedef int (*func)(int,int);//给函数类型定义别名

func func1;

func1=add;//给函数指针初始化

或者int (*func1)(int,int)=add;

函数指针的好处:

假设有10个函数:add,sub,mul,div,...如果采用普通的switch()  case:

switch(status)

{

　　case 0:add(2,3);break;

　　case 1:sub(2,3);break;

　　case 1:sub(2,3);break;

　　case 1:sub(2,3);break;

　　...

}

//缺点,如果函数过多,假设有100个case,那么调用某个case的效率会很低,因为case是从第一个case逐一比较,知道匹配为止,因此必须尽量把调用概率高的case放在最前面,以减少匹配比较的次数

如果采用函数指针来实现:

typedef int (*pFunc)(int,int);

pFunc func[10]={add,sub,mul,div,...};

func[status](2,3);//直接调用某个指定的函数,效率很高,而且每个函数的效率与访问的概率和匹配比较的次数无关

总结:采用函数指针是动态绑定,而采用switch case哪种类型的是静态绑定,即编译时就决定了调用哪个函数,而不是等到运行时才决定


3.C++中把函数指针封装成了一个类,这也正是C++中无处不类的思想的体现,即std::function,还是个模板类

需要包含的头文件:

#include<functional>

using namespace std;

 std::function<int(int ,int)>func=add;//<int(int,int)>是实例化模板参数,表示返回值为int,函数参数为2个,(int,int),即int(*pfunc)(int ,int )类型的函数

int res=func(3,4);//仿函数调用

cout<<res<<endl;//res=7


4.仿函数在C++类成员函数中的使用便利之处

传统的类成员函数指针的使用方法:

class test{

public:

　　int add(int a,int b)

　　{

　　　　return a+b;

　　}

}

typedef int (*PFUNC)(int ,int);//使用类型别名的成员函数指针

PFUNC pfunc;

test::pfunc=test::add


5.传统的成员函数指针的用法:

int( test::*pfunc)(int ,int)=&test::add; //类成员函数指针的定义

调用:

(this->*)pfunc(3,4);//太复杂了


6.bind的功能:把一个具体函数,变成std::function对象

void func(int a,char b,float c)

{

　　cout<<"a="<<a<<"b="<<b<<"c="<<c<<endl;

}

将bind与一个普通函数绑定:


6.1可以改变参数的个数,实际上是在绑定时已经给了默认参数,

std::function<void()>pfunc=std::bind(func,100,'c',2.5);//绑定

pfunc();//调用,此时可以不用传任何参数,因为在绑定时,已经提供了参数


6.2  改变参数的顺序

std::function<void(float,char,int)>pfunc=std::bind(func,std::placeholders::_3,std::placeholders::_2,std::placeholders::_1);

pfunc(5.5,'a',10);//调用时参数的顺序改变了,变成了(float,char,int)


6.3也可以同时改变参数额个数和顺序

std::function<void(float,char)>pfunc=std::bind(func,100,std::placeholders::_2,std::placeholders::_1);//这里的_2代表实参列表中的第二个参数'x',_1代表实参列表中的第一个参数9.9,但是bind中参数的顺序仍然要按照被调用函数的参数顺序来,即(int,char,float)

pfunc(9.9,'x');//省略了int参数,且改变了float和char的顺序

7.包装lambda表达式

#include <iostream>
#include <functional>
using namespace std;
auto g_Minus = [](int i, int j){ return i - j; };
int main()
{
    function<int(int, int)> f = g_Minus;
    cout << f(1, 2) << endl;                                            // -1
    return 1;
}

8.包装函数对象非模板类型：

#include <iostream>
#include <functional>
using namespace std;

struct Minus
{
    int operator() (int i, int j)
    {
        return i - j;
    }
};

int main()
{
    function<int(int, int)> f = Minus();
    cout << f(1, 2) << endl;                                            // -1
    return 1;
}
8.1 模板类 

#include <iostream>
#include <functional>
using namespace std;

template <class T>
struct Minus
{
    T operator() (T i, T j)
    {
        return i - j;
    }
};

int main()
{
    function<int(int, int)> f = Minus<int>();
    cout << f(1, 2) << endl;                                            // -1
    return 1;
}

9.包装类静态函数

#include <iostream>
#include <functional>
using namespace std;
class Math
{
public:
    static int Minus(int i, int j)
    {
        return i - j;
    }
};

int main()
{
    function<int(int, int)> f = &Math::Minus;
    cout << f(1, 2) << endl;                                            // -1
    return 1;
}

10 .包装类对象成员函数（非模板类型：）

复制代码 
#include <iostream>
#include <functional>
using namespace std;

class Math
{
public:
    int Minus(int i, int j)
    {
        return i - j;
    }
};

int main()
{
    Math m;
    function<int(int, int)> f = bind(&Math::Minus, &m, placeholders::_1, placeholders::_2);
    cout << f(1, 2) << endl;                                            // -1
    return 1;
}
复制代码

       模板类型：

复制代码 
#include <iostream>
#include <functional>
using namespace std;

class Math
{
public:
    template <class T>
    T Minus(T i, T j)
    {
        return i - j;
    }
};

int main()
{
    Math m;
    function<int(int, int)> f = bind(&Math::Minus<int>, &m, placeholders::_1, placeholders::_2);
    cout << f(1, 2) << endl;                                            // -1
    return 1;
}


11.bind的设计思想;

高内聚,低耦合,使被调用的函数和调用者完全隔离开来.调用者可以根据需要任意设计接口,和传参,而被调用函数通过bind可以不经修改接口就可以兼容各种需求的变化.

区别于静态绑定,动态绑定,这属于程序员自动绑定.

使用 汇总

template<class T> T sub(T a,T b); 
template<class T> T devide(T a, T b);
template<class T> T multiply(T a, T b);
typedef int(*func)(int, int);
void UseFunction()
{
int status=0;
func fun1 = add;  //函数的动态绑定  区别于静态绑定 
func pfun[4] = { add, sub, devide, multiply };   // 函数集合 动态绑定 
int sum =pfun[status](2,4);   // 函数数指针是动态绑定  减少匹配次数    
// function 函数的使用  
std::function<int(int, int)>  funct = add;   //  实例化模板函数 
int res = funct(2,3);     // founction 函数的调用   
// 将bind与一个普通函数绑定  
std::function<int(int, int)> pfunc = std::bind(add,2,3); 
// 使用bind 调换 函数的顺序  
std::function<void(int, CString, float)> SortFunction = bind(showFunction, std::placeholders::_3, std::placeholders::_2, std::placeholders::_1);
SortFunction(5.5,_T("test"),3);  //  pfunc(5.5,'a',10);//调用时参数的顺序改变了,变成了(float,char,int) 

}   

线程池

运行效果

image

 

背景

在传统的收到任务即创建线程的情况下，我们每收到一个任务，就创建一个线程，执行任务，销毁线程，

我们把这三个过程所用的时间分别记做T1,T2,T3

任务本身所用的时间仅占T2/(T1+T2+T3),这在任务本身所用时间很短的情况下， 效率是很低的

此外，通常操作系统所能创建的线程数量都是有限的，并不能无限制的创建线程。

 

而在线程池中，我们通常会预先创建m个线程，放到空闲容器中，当有任务来临时，线程池会从空闲的线程中挑选一个线程来执行该任务，

在执行完毕后再将其放回空闲容器中

 

C++11

在C++11中，C++对线程提供了一个很高的抽象，并没有很好的提供优先级控制等功能，需要调用std::thread::native_handle()，获取原生线程对象

运行平台特定的操作，但这就丧失了std::thread在不同平台上代码层面的一致性。

所以在项目中实现了对std::thread二次封装，并提供了基本的优先级控制

 

项目概述

项目中有一个主线程，即运行程序时创建的线程可以从用户那里获取任务，还有一个管理线程，用于进行线程池中线程的调度，还有初始化线程池时创建的若干空闲线程，用于执行任务

 

项目中主要有以下几个类：

Task:任务类，内有任务的优先级，和一个纯虚Run方法，我们需要派生Task，将要完成的任务写到Run方法中

MyThread：线程类，封装了C++11的thread，每一个线程可以关联一个Task对象，执行其Run方法

BusyThreadContainer:工作容器类，采用std::list<MyThread*>实现，储存工作状态的线程

IdleThreadContainer:空闲容器类，采用std::vector<MyThread*>实现，储存处于空闲状态的线程

TaskContainer:任务容器类，采用priority_queue<Task*>实现,储存所有用户添加未执行的任务

MyThreadPool:线程池类，用于从用户获取任务，管理任务，实现对线程池中线程的调度

 

类图如下

MainDig

*UserTask为用户自己编写的从Task派生的任务类

 

Task类

复制代码 
namespace
{
    enum  PRIORITY
    {

        MIN = 1, NORMAL = 25, MAX = 50
    };
}

class Task
{
    
public:
    Task()
    {

    }
    void SetPriority(int priority)
    {
        if (priority>(PRIORITY::MAX))
        {
            priority = (PRIORITY::MAX);
        }
        else if (priority>(PRIORITY::MAX))
        {
            priority = (PRIORITY::MIN);
        }
    }    
    virtual void Run() = 0;
protected:
    int priority_;
};
复制代码 
 

void SetPriority(int priority) ：设置线程的优先级，数值在1-50之间，值越大，优先级越高

virtual void run() = 0：线程执行的方法，用户需要重写为自己的方法

 

MyThread类

复制代码 
class MyThread
{
    friend bool operator==(MyThread my1, MyThread my2);
    friend bool operator!=(MyThread my1, MyThread my2);
public:
    MyThread(MyThreadPool *pool);
    void Assign(Task *Task);
    void Run();
    void StartThread();
    int getthreadid();
    void setisdetach(bool isdetach);    
private:
    MyThreadPool *mythreadpool_;
    static int  s_threadnumber;
    bool isdetach_;
    Task *task_;
    int threadid_;
    std::thread thread_;
};
复制代码

方法：

MyThread(MyThreadPool *pool)：构造一个MyThread对象，将自己与指定的线程池相关联起来

void Assign(Task *Task)：将一个任务与该线程相关联起来

void Run()：调用了Task的Run方法，同时在Task的Run方法结束后将自己从工作容器移回空闲容器

void StartThread()：执行线程的Run方法，即执行了Task的Run方法

int getthreadid()：获取线程的id号

void setisdetach(bool isdetach)：设置线程在运行的时候是join还是detach的

 

BusyThreadContainer类

复制代码 
class BusyThreadContainer
{
    
public:
    BusyThreadContainer();
    ~BusyThreadContainer();
    void push(MyThread *m);
    std::list<MyThread*>::size_type size();
    void erase(MyThread *m);

private:
    std::list<MyThread*> busy_thread_container_;
    typedef std::list<MyThread*> Container;
    typedef Container::iterator Iterator;
};
复制代码 
 

void push(MyThread *m)：将一个线程放入工作容器中

void erase(MyThread *m)：删除一个指定的线程

std::list<MyThread*>::size_type size()：返回工作容器的大小

 

 

IdleThreadContainer类

复制代码 
class IdleThreadContainer
{
    
public:
    IdleThreadContainer();
    ~IdleThreadContainer();
    std::vector<MyThread*>::size_type size();
    void push(MyThread *m);
    void assign(int n,MyThreadPool* m);    
    MyThread* top();
    void pop();
    void erase(MyThread *m);
private:
    std::vector<MyThread*> idle_thread_container_;
    typedef std::vector<MyThread*> Container;
    typedef Container::iterator Iterator;
};
复制代码

~IdleThreadContainer(); ：负责析构空闲容器中的线程

void push(MyThread *m)：将一个线程放回空闲容器中

void assign(int n,MyThreadPool* m)：创建n个线程与线程池m相关联的线程放入空闲容器中

MyThread* top()：返回位于空闲容器顶端的线程

void pop()：弹出空闲容器顶端的线程

void erase(MyThread *m)：删除一个指定的线程

 

 

 

TaskContainer类

复制代码 
class TaskContainer
{
public:
    TaskContainer();
    ~TaskContainer();
    void push(Task *);
    Task* top();
    void pop();
    std::priority_queue<Task*>::size_type size();
private:
    std::priority_queue<Task*> task_container_;
};
复制代码

void push(Task *)：将一个任务放入任务容器中

Task* top()：返回任务容器顶端的任务

void pop()：将任务容器顶端的线程弹出

std::priority_queue<Task*>::size_type size()：返回任务容器的大小

 

MyThreadPool类

复制代码 
class MyThreadPool
{
public:
    
    MyThreadPool(){}
    MyThreadPool(int number);
    ~MyThreadPool();
    void AddTask(Task *Task,int priority);
    void AddIdleThread(int n);
    void RemoveThreadFromBusy(MyThread *myThread);
    void Start();
    void EndMyThreadPool();private:
    BusyThreadContainer busy_thread_container_;
    IdleThreadContainer idle_thread_container_;
    bool issurvive_;
    TaskContainer task_container_;
    std::thread thread_this_;
    std::mutex busy_mutex_;
    std::mutex idle_mutex_;
    std::mutex task_mutex_;
    int number_of_thread_;
};
复制代码

MyThreadPool(int number)：构造MyThreadPool，创建包含number个线程的空闲容器

void AddTask(Task *Task,int priority)：添加一个优先级为priority的任务到任务容器中

void AddIdleThread(int n)：在创建n个空闲线程到空闲容器中

void RemoveThreadFromBusy(MyThread *myThread)：将一个线程从工作容器中删除，并移回空闲容器中

void Start()：判断是否有空闲线程，如有将任务从从任务容器中提出，放入空闲容器中，等待执行

void EndMyThreadPool()：结束线程池的运行

 

派生自Task的MyTask类

复制代码 
class MyTask :public Task
{
    friend bool operator<(MyTask  &lv,MyTask &rv)
    {
        return lv.priority_ < rv.priority_;
    }
public:
    MyTask();
    ~MyTask();
    virtual void Run();
    void setdata(int d);
private:
    int data_;
};
复制代码
复制代码 
MyTask::MyTask()
{
}
MyTask::~MyTask()
{
}
void MyTask::setdata(int d)
{
    data_ = d;
}
void MyTask::Run()
{
    std::cout << "Hello I am "<<data_ << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(1));
}
复制代码

friend bool operator<(MyTask &lv,MyTask &rv) ：用于确定任务在任务容器中的位置

Run：自定义的Run方法

void setdata(int d)：设置数据

 

关键代码分析：

void MyThread::Run()

复制代码 
void MyThread::Run()
{
    cout <<"Thread:"<< threadid_ << " run ";
    task_->Run();
    mythreadpool_->RemoveThreadFromBusy(this);
}
复制代码

调用了Task的Run方法，同时在Task的Run方法结束后，通知线程池将自己从工作容器中移回空闲容器

 

void MyThread::StartThread()

复制代码 
void MyThread::StartThread()
{
    thread_ = thread(&MyThread::Run, this);
    if (isdetach_ == true)
        thread_.detach();
    else
        thread_.join();
}
复制代码

将MyThread的Run方法与thread_相绑定，this表示类的Run方法的第一个隐含的参数

然后根据isdetach的值，判断是否detach() or join()

 

void MyThreadPool::RemoveThreadFromBusy(MyThread *myThread)

复制代码 
void MyThreadPool::RemoveThreadFromBusy(MyThread *myThread)
{

    busy_mutex_.lock();
    cout << "Thread:" << myThread->getthreadid()<< " remove from busylist" << endl;
    busy_thread_container_.erase(myThread);
    busy_mutex_.unlock();

    idle_mutex_.lock();
    idle_thread_container_.push(myThread);
    idle_mutex_.unlock();
}
复制代码

将一个线程从任务容器中移除，并将其放回空闲容器中，

使用busy_mutex_和idle_mutex_进行加锁和解锁，确保数据的一致性

 

MyThreadPool::MyThreadPool(int number)

复制代码 
MyThreadPool::MyThreadPool(int number)
{
    issurvive_ = true;
    number_of_thread_ = number;
    idle_thread_container_.assign(number, this);
    thread_this_ =thread(&MyThreadPool::Start, this);
    thread_this_.detach();
}
复制代码

MyThreadPool的构造函数，创建number个空闲线程与空闲容器中，同时创建管理线程thread_this，用于进行线程池中线程的调度

 

void MyThreadPool::Start()

复制代码 
void MyThreadPool::Start()
{
    
    while (true)
    {
        if (issurvive_==false)
        {
            busy_mutex_.lock();
            if (busy_thread_container_.size()!=0)
            {
                busy_mutex_.unlock();
                continue;
            }
            busy_mutex_.unlock();
            break;
        }
        idle_mutex_.lock();
        if (idle_thread_container_.size() == 0)
        {
            idle_mutex_.unlock();
            continue;
        }
        idle_mutex_.unlock();
        task_mutex_.lock();
        if (task_container_.size() == 0)
        {
            task_mutex_.unlock();
            continue;
        }
        Task *b = task_container_.top();;
        task_container_.pop();
        task_mutex_.unlock();
        
        idle_mutex_.lock();
        MyThread *mythread = idle_thread_container_.top();;
        idle_thread_container_.pop();
        mythread->Assign(b);
        idle_mutex_.unlock();

        busy_mutex_.lock();
        busy_thread_container_.push(mythread);
        busy_mutex_.unlock();
        mythread->StartThread();
    }
}
复制代码

管理线程对应的Start方法，内有一个死循环，不停的判断任务容器中是否有任务，和是否有空闲线程来执行任务，若有，则将任务从

任务容器中提出，从空闲线程中提取出一个空闲线程与其绑定，执行该任务，同时将该线程从空闲容器移动到工作容器中。

当线程池想要结束运行时，即survive为false时，首先要判断工作容器是否为空，若不为空，则代表还有任务正在被线程执行，线程池不能结束运行

否则可以结束线程池的运行，跳出死循环

 

int main()

复制代码 
int main()
{
    MyThreadPool mythreadPool(10);

    MyTask j[50];
    for (int i = 0; i < 50;i++)
    {
        j[i].setdata(i);
    }
    for (int i = 0; i < 50; i++)
    {
        mythreadPool.AddTask(&j[i],i);
    }
    int i;
    //按100添加一个任务
    //按-1结束线程池
    while (true)
    {
        cin >> i;    
        if (i == 100)
        {
            MyTask j;
            j.setdata(i);
            mythreadPool.AddTask(&j, i);
        }
        if (i == -1)
        {        
            mythreadPool.EndMyThreadPool();
            break;
        }        
    }
    system("pause");
}
复制代码

创建了一个含有10个空闲线程的线程池，和50个MyTask任务，并将其放入线程池中等待运行

在循环中，用户输入100可以再添加一个任务到线程池中等待运行，输入-1结束线程池的运行。

运行结果如下

image

 

 

线程池使用后记

线程池并不是万能的，线程池减少了创建与销毁线程本身对任务照成的影响，但如果任务本身的运行时间很长，那么这些开销相当于任务本身执行开销而言是可以忽略的。那么我们也可以

选择“即时创建，即时销毁”的策略

线程池通常适合下面的几个场合：

(1)  单位时间内处理的任务数较多，且每个任务的执行时间较短

(2)  对实时性要求较高的任务，如果接受到任务后在创建线程，再执行任务，可能满足不了实时要求，因此必须采用线程池进行预创建。

AREH
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++11 符号修饰与函数签名、函数指针、匿名函数、仿函数、std::function与std::bind
08-19
`std::function`是一个模板类，可以存储任何类型的可调用对象（包括普通函数、成员函数、函数指针和仿函数等）。`std::bind`则允许我们部分绑定函数参数，创建一个新的可调用对象。例如，`std::function(int)> func`...
函数指针模板
tianyexing2008的博客
09-14 1094
我们一般声明的函数指针，如：void (*funcPro)(int)，那用这个函数指针类型定义的变量，可以指向一个“返回值是 void，带一个 int 类型的参数的函数”。这些宏最终的目的是把 两个参数连在一起，即经过 BOOST_JOIN(function,BOOST_FUNCTION_NUM_ARGS) 后，BOOST_FUNCTION_FUNCTION=functionBOOST_FUNCTION_NUM_ARGS，而这个 BOOST_FUNCTION_NUM_ARGS 是一个宏，那这个宏是什么呢？
关于变参函数指针以及变参Function模板
陶醉鱼的博客
04-17 1463
关于变参函数指针以及变参Function模板
C++函数指针和模板
芒种、的博客
12-24 3175
一、函数指针声明 //函数原型 double sum(double,double); //函数指针的声明 double (*ptrSum)(double,double) 注意： 1，该语句声明了一个指针ptrSum,指向一个函数。 2，double *ptrSum(double,double) 不是函数指针 而是：声明一个函数，返回值为double *类型（指针函数）。 3，需要先定义函数，然后再定义函数指针。 //定义一个函数指针类型 typedef int (*FuncType)(int, int
C++11：可变参数模板、lambda表达式和包装器
weixin_43908419的博客
05-29 1692
本文对C++11的可变参数模板、lambda表达式和包装器进行了解读。
c/c++ 标准库 bind 函数详解
08-26
这里的`F`代表可调用对象（如函数指针、函数对象、成员函数等），`Args`是传递给`bind`的参数列表。`bind`返回一个`std::function`类型的对象，这个对象可以像普通函数一样被调用，但它的行为是由`f`和`args`决定的...
理解C++编程中的std::function函数封装
09-02
在C++编程中，`std::function`是一个强大的工具，它是C++11标准引入的新特性，用于封装和管理各种可调用实体，如普通函数、Lambda表达式、函数指针以及自定义的函数对象。这个特性使得在C++程序中更加灵活地处理函数...
C++11中lambda、std::function和std:bind详解
08-31
**std::function**是C++11标准库中的一个类模板，用于封装任何可调用对象（如函数指针、成员函数指针、函数对象或lambda表达式）。它的优势在于可以将不同类型的可调用对象存储在一个统一的接口中，提供了类型安全和...
c++类成员函数作为回调函数
12-01
总结来说，C++中将类成员函数作为回调函数涉及到了多种技术，包括使用静态成员函数、`std::function`、`std::bind`、`std::mem_fn`、`std::shared_ptr`以及回调对象等。理解并熟练掌握这些方法，能够帮助开发者在...
C++模板编程->函数指针模板参数
Rana专栏
04-05 2502
template void foreach(T array[],unsigned size) { for (int i = 0; i < size; ++i) { f(array[i]); } } template void inc(T &v){++v;} template void dec(T &v){--v;} template vo
模板与成员函数指针
u011647007的专栏
08-08 916
#include &lt;iostream&gt; #include &lt;list&gt; using namespace std; /*包装类，成员函数指针类型与普通函数指针类型不同，不能在类外直接定义*/ template &lt;class T, class _Ty&gt; class CPtrMaker { public:     //自定义成员函数指针类型     typedef...
函数指针 指针函数 模板类 类模板 函数模板 模板函数
qq_33774935的博客
08-31 833
指针函数：本质是一个函数，函数的返回值是某一类型的指针。形式一般如下： 类型标识符  *  函数名（参数列表） 如 int * f（x，y）. 函数指针：本质上是指针，它指向的是一个函数。形式一般如下：类型标识符 （*函数名）（参数） 如 int （*pf）（int x）。 数组指针： int （*p）[ 4 ]. 指针数组： int * p [ 4 ] . 函数模板：对一批模样相同的函数
函数指针与模板
噬日者
06-12 2082
<br />#include "stdafx.h" #include <iostream> using namespace std; template<typename T> class A { private: typedef int (T::*delegateFun)(int); // 将T类中的函数设置未typedef typedef int (T::*unknowFun)(int,int); T *_This;
定义指向模板函数的函数指针类型
MyDriverC
09-02 6388
http://bbs.csdn.net/topics/390010520 C/C++ code ? 1 2 3 4 5 template typename PktType> typedef int (* CallbackFunPtrType) (const PktType& CurPkt);/
c++函数模板与函数指针
abc15766228491的博客
12-12 5234
函数指针 1、概念：与数据项相似，函数也有地址，函数的地址是存储其机器语言代码的内存的开始地址。获取函数的地址很简单：只要使用函数名（后面不跟参数）即可。也就是说，如果think()是一个函数，则think就是该函数的地址。要将函数作为参数进行传递，必须传递函数名。(《C++ Primer Plus 中文版》(第五版 p216)） 2、声明函数指针：double(*pf)(int)，即声明了一个函...
函数指针模板参数
microsoftwin32的专栏
07-05 3328
同样，函数指针型模板参数的意义在于：在变与不变之间取得最优实现。通常函数指针的作用是实现回调（callback），即由调用方将所需要操作包装成某个函数f0，并将指向此函数的指针&f0作为参数传递给函数f1。函数f1在运行时回调所指函数f0，从而实现调用方所期待操作。f0就是一个回调函数。将回调函数指针作为被调用函数的参数时，实现的是动态回调，只有在运行时才能确定是回调哪个函数。如果并不需要动态回调
c++类的成员函数不能作为类的函数指针传入吗
最新发布
06-10
因此，如果要将类成员函数作为函数指针传入，需要使用std::function或者函数指针类型来声明。同时，需要使用std::bind或者lambda表达式将类成员函数与this指针绑定起来，以便正确地调用类成员函数。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值