线程池

最新推荐文章于 2023-07-04 10:52:56 发布
最新推荐文章于 2023-07-04 10:52:56 发布
阅读量251 收藏
点赞数
分类专栏： 线程池 文章标签： QT C 线程池
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cLover_xiaolei/article/details/79533769
版权

下面将从线程的设计思路及线程池的使用进行说明。

线程池管理主体设计思路是：

1、封装线程管理对象 MyThread，用于线程创建、线程开启、线程睡眠、任务绑定等操作。

2、封装空闲线程栈管理对象IdleThreadContainer，用于空闲线程栈的维护管理等操作。空闲的线程放于此栈中。

3、封装忙碌线程队列管理对象BusyThreadContainer，用于忙碌线程队列的维护及管理等操作。忙碌的线程放于此队列中。

4、封装任务管理对象MyTask，用于线程函数等任务信息的设置操作。

5、封装任务队列管理对象TaskContainer，用于任务队列的管理及维护等操作。

6、封装线程池管理对象CThreadPoolExp，用于线程池线程创建、线程任务添加、线程任务调度、忙碌线程及空闲线程队列维护管理等操作。开启一个管理线程，对线程任务调度进行管理。

#include <windows.h>

class  Task;
class CBaseThreadPool;

class MyThread
{
public:
    MyThread(CBaseThreadPool *pBaseThreadPool);
    virtual ~MyThread(void);
public:
    bool	StartMyThread();
    bool	CloseMyThread();
    bool	SuspendMyThread();
    bool	ResumeMyThread();
    bool	AssignTask(Task *pTask);
    bool	StartTask();
    static unsigned _stdcall ThreadProc(LPVOID lParam);
private:
    static void ReleaseMemory(MyThread *pThread);
public:
    DWORD			m_iThreadID;
    HANDLE			m_hThread;
    CBaseThreadPool *m_pBaseThreadPool;
private:
    bool			m_bIsExit;
    HANDLE			m_hEvent;
    Task			*m_pTask;
};
#include "mythread.h"
#include <process.h>
#include "task.h"
#include "ThreadPoolExp.h"


MyThread::MyThread(CBaseThreadPool *pBaseThreadPool)
    : m_iThreadID(0)
    , m_hThread(NULL)
    , m_pBaseThreadPool(pBaseThreadPool)
    , m_bIsExit(true)
    , m_hEvent(NULL)
    , m_pTask(NULL)
{
    m_hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
}


MyThread::~MyThread(void)
{
    CloseHandle(m_hEvent);
}

bool MyThread::StartTask()
{
    if ( NULL == m_pTask )
        return false;
    return ResumeMyThread();
}

unsigned _stdcall MyThread::ThreadProc(LPVOID lParam)
{
    MyThread *pThread = static_cast<MyThread *>(lParam);
    if ( NULL == pThread )
        return 1;
    DWORD ret = WAIT_FAILED;
    while (!pThread->m_bIsExit)
    {
        ret = WaitForSingleObject(pThread->m_hEvent, INFINITE);
        if ( WAIT_OBJECT_0 == ret )
        {
            if ( pThread->m_pTask )
            {
                pThread->m_pTask->TaskProc();
                //任务完成清除任务释放资源
                ReleaseMemory(pThread);
                //线程挂起，根据当前是否有新任务来判断是否将当前线程放入空闲线程栈
                pThread->m_pBaseThreadPool->SwitchActiveThread(pThread);
            }
        }
    }
    return 0;
}

void MyThread::ReleaseMemory(MyThread *pThread)
{
    if(!pThread)
    {
        return;
    }
    if(pThread->m_pTask)
    {
        delete(pThread->m_pTask);
        pThread->m_pTask = NULL;
    }
}

bool MyThread::StartMyThread()
{
    if ( !m_bIsExit )
        return true;
    m_hThread = (HANDLE)_beginthreadex(NULL, 0, ThreadProc, (LPVOID)this, 0, NULL);
    if ( NULL == m_hThread )
        return false;
    m_iThreadID = GetThreadId(m_hThread);
    m_bIsExit = false;
    return true;
}

bool MyThread::CloseMyThread()
{
    if ( NULL == m_hThread )
        return true;
    m_bIsExit = true;
    m_pTask = NULL;
    ResumeMyThread();
    WaitForSingleObject(m_hThread, INFINITE);
    CloseHandle(m_hThread);
    return true;
}

bool MyThread::SuspendMyThread()
{
    if ( NULL == m_hThread )
        return false;
    ResetEvent(m_hEvent);
    return true;
}

bool MyThread::ResumeMyThread()
{
    if ( NULL == m_hThread )
        return false;
    SetEvent(m_hEvent);
    return true;
}

bool MyThread::AssignTask(Task *pTask)
{
    if ( NULL == pTask )
        return false;
    m_pTask = pTask;
    return true;
}
#include <vector>
#include <stack>
#include "typedef.h"


class MyThread;

class IdleThreadContainer
{
public:
    IdleThreadContainer(void);
    virtual ~IdleThreadContainer(void);
public:
    MyThread*	Pop();
    bool		Push(MyThread *pThread);
    bool		IsEmpty();
    bool		Clear();
    int			GetSize();
private:
    std::stack<MyThread *> m_ThreadStack;
    CMyLock m_AutoLock;
};
#include "idlethreadcontainer.h"
#include "mythread.h"


IdleThreadContainer::IdleThreadContainer(void)
    : m_AutoLock(CMyLock())
{
}


IdleThreadContainer::~IdleThreadContainer(void)
{
}

MyThread* IdleThreadContainer::Pop()
{
    if ( IsEmpty() )
        return NULL;
    MyThread *pThread = NULL;
    CMyAutoLock autoLock(&m_AutoLock);
    if ( m_ThreadStack.empty() )
        return NULL;
    pThread = m_ThreadStack.top();
    pThread->ResumeMyThread();
    m_ThreadStack.pop();
    return pThread;
}

bool IdleThreadContainer::Push(MyThread *pThread)
{
    if ( NULL == pThread )
        return false;
    CMyAutoLock autoLock(&m_AutoLock);
    pThread->SuspendMyThread();
    m_ThreadStack.push(pThread);
    return true;
}

bool IdleThreadContainer::IsEmpty()
{
    CMyAutoLock autoLock(&m_AutoLock);
    bool ret = m_ThreadStack.empty();
    return ret;
}

bool IdleThreadContainer::Clear()
{
    if ( IsEmpty() )
        return true;
    CMyAutoLock autoLock(&m_AutoLock);
    MyThread *pThread = NULL;
    while (!m_ThreadStack.empty())
    {
        pThread = m_ThreadStack.top();
        pThread->CloseMyThread();
        delete pThread;
        m_ThreadStack.pop();
    }
    return true;
}

int IdleThreadContainer::GetSize()
{
    CMyAutoLock autoLock(&m_AutoLock);
    int iSize = m_ThreadStack.size();
    return iSize;
}

#include <list>
#include "typedef.h"

class MyThread;

class BusyThreadContainer
{
public:
    BusyThreadContainer(void);
    virtual ~BusyThreadContainer(void);
public:
    bool		AddThread(MyThread *pThread);
    bool		RemoveThread(MyThread *pThread);
    bool		IsEmpty();
    bool		Clear();
    int			GetSize();
private:
    std::list<MyThread *> m_ThreadList;
    CMyLock m_AutoLock;
};

#include "busythreadcontainer.h"
#include "mythread.h"


BusyThreadContainer::BusyThreadContainer(void)
    : m_AutoLock(CMyLock())
{
}


BusyThreadContainer::~BusyThreadContainer(void)
{
}

bool BusyThreadContainer::AddThread(MyThread *pThread)
{
    if ( NULL == pThread )
        return false;
    CMyAutoLock autoLock(&m_AutoLock);
    m_ThreadList.push_back(pThread);
    return true;
}

bool BusyThreadContainer::RemoveThread(MyThread *pThread)
{
    if ( NULL == pThread || IsEmpty() )
        return false;
    CMyAutoLock autoLock(&m_AutoLock);
    if ( IsEmpty() )
        return false;
    m_ThreadList.remove(pThread);
    return true;
}

bool BusyThreadContainer::IsEmpty()
{
    CMyAutoLock autoLock(&m_AutoLock);
    bool ret = m_ThreadList.empty();
    return ret;
}

bool BusyThreadContainer::Clear()
{
    if ( IsEmpty() )
        return true;
    CMyAutoLock autoLock(&m_AutoLock);
    std::list<MyThread *>::iterator it = m_ThreadList.begin();
    while ( it != m_ThreadList.end() )
    {
        (*it)->CloseMyThread();
        delete *it;
        ++it;
    }
    m_ThreadList.clear();
    return true;
}

int BusyThreadContainer::GetSize()
{
    CMyAutoLock autoLock(&m_AutoLock);
    int iSize = m_ThreadList.size();
    return iSize;
}


#include "typedef.h"

namespace
{
    enum PRIORITY
    {
        MIN = 1, NORMAL = 25, MAX = 50
    };
}

typedef bool (*pTaskFun)(LPVOID lParam);

class Task
{
public:
    Task():m_iTaskID(0) {}
    Task(int id):m_iTaskID(id) {}
    Task(int id, pTaskFun TaskFunAddress, LPVOID lParam)
        : m_iTaskID(id)
        , m_pTaskFun(TaskFunAddress)
        , m_lParam(lParam)
    {
    }
    virtual ~Task() {}
public:
    int GetID() { return m_iTaskID; }
    virtual bool SetTaskInfo(int id, pTaskFun TaskFunAddress, LPVOID lParam) = 0;
    virtual bool TaskProc() = 0;
    virtual bool TaskProc(pTaskFun TaskFunAddress, LPVOID lParam) = 0;
protected:
    int					m_iTaskID;
    pTaskFun			m_pTaskFun;
    LPVOID				m_lParam;
};

class MyTask
    : public Task
{
public:
    MyTask() {}
    MyTask(int id);
    MyTask(int id, pTaskFun TaskFunAddress, LPVOID lParam);
    virtual ~MyTask(void);
public:
    virtual bool SetTaskInfo(int id, pTaskFun TaskFunAddress, LPVOID lParam);
    virtual bool TaskProc();
    virtual bool TaskProc(pTaskFun TaskFunAddress, LPVOID lParam);
};
#include "task.h"

MyTask::MyTask(int id)
    : Task(id)
{
}

MyTask::MyTask(int id, pTaskFun TaskFunAddress, LPVOID lParam)
    : Task(id, TaskFunAddress, lParam)
{

}

MyTask::~MyTask(void)
{
}

bool MyTask::SetTaskInfo(int id, pTaskFun TaskFunAddress, LPVOID lParam)
{
    if ( NULL == TaskFunAddress || NULL == lParam )
        return false;
    m_iTaskID = id;
    m_pTaskFun = TaskFunAddress;
    m_lParam = lParam;
    return true;
}

bool MyTask::TaskProc()
{
    if ( NULL == m_pTaskFun || NULL == m_lParam )
        return false;
    return m_pTaskFun(m_lParam);
}

bool MyTask::TaskProc(pTaskFun TaskFunAddress, LPVOID lParam)
{
    if ( NULL == TaskFunAddress || NULL == lParam )
        return false;
    return TaskFunAddress(lParam);
}


#include <deque>
#include "typedef.h"

class Task;

class TaskContainer
{
public:
    TaskContainer(void);
    virtual ~TaskContainer(void);
public:
    Task*	Pop();
    bool	Push(Task *pTask);
    bool	PushFront(Task *pTask);
    bool	IsEmpty();
    bool	Clear();
    int		GetSize();
private:
    std::deque<Task *> m_TaskQueue;
    CMyLock m_AutoLock;
};


#include "taskcontainer.h"
#include "task.h"

TaskContainer::TaskContainer(void)
    : m_AutoLock(CMyLock())
{
}


TaskContainer::~TaskContainer(void)
{
}

Task* TaskContainer::Pop()
{
    if ( IsEmpty() )
        return NULL;
    Task *pTask = NULL;
    CMyAutoLock autoLock(&m_AutoLock);
    if ( m_TaskQueue.empty() )
        return NULL;
    pTask = m_TaskQueue.front();
    m_TaskQueue.pop_front();
    return pTask;
}

bool TaskContainer::Push(Task *pTask)
{
    if ( NULL == pTask )
        return false;
    CMyAutoLock autoLock(&m_AutoLock);
    m_TaskQueue.push_back(pTask);
    return true;
}

bool TaskContainer::PushFront(Task *pTask)
{
    if ( NULL == pTask )
        return false;
    CMyAutoLock autoLock(&m_AutoLock);
    m_TaskQueue.push_front(pTask);
    return true;
}

bool TaskContainer::IsEmpty()
{
    CMyAutoLock autoLock(&m_AutoLock);
    bool ret = m_TaskQueue.empty();
    return ret;
}

bool TaskContainer::Clear()
{
    CMyAutoLock autoLock(&m_AutoLock);
    m_TaskQueue.clear();
    return true;
}

int TaskContainer::GetSize()
{
    CMyAutoLock autoLock(&m_AutoLock);
    int iSize = m_TaskQueue.size();
    return iSize;
}


#include <Windows.h>
#include <process.h>
#include "typedef.h"
#include "taskcontainer.h"
#include "idlethreadcontainer.h"
#include "busythreadcontainer.h"


class Task;
class MyThread;

class CBaseThreadPool
{
public:
    CBaseThreadPool() {}
    virtual ~CBaseThreadPool() {}
public:
    virtual int			SetThreadNum(int iThreadNum) = 0;
    virtual bool		AddTask(Task *pTask, TASK_PRIORITY priority) = 0;
    virtual Task*		GetNewTask() = 0;
    virtual MyThread*	GetIdleThread() = 0;
    virtual bool		SwitchActiveThread(MyThread *pThread) = 0;
    virtual bool		StartThreadPool() = 0;
    virtual bool		DestroyThreadPool() = 0;
    virtual bool		IsExit() = 0;
};

class CThreadPoolExp
    : public CBaseThreadPool
{
public:
    CThreadPoolExp(void);
    virtual ~CThreadPoolExp(void);
public:
    virtual int			SetThreadNum(int iThreadNum);
    virtual bool		AddTask(Task *pTask, TASK_PRIORITY priority);
    virtual Task*		GetNewTask();
    virtual MyThread*	GetIdleThread();
    virtual bool		SwitchActiveThread(MyThread *pThread);
    virtual bool		StartThreadPool();
    virtual bool		DestroyThreadPool();
    virtual bool		IsExit();
public:
    static unsigned _stdcall ThreadProc(LPVOID lParam);
private:
    bool SuspendThread();
    bool ResumeThread();
    bool ManageThreads();
private:
    bool				m_bIsExit;
    bool                m_bIsResumed;       //线程是否被唤起
    int					m_iThreadNum;
    HANDLE				m_hThread;
    HANDLE				m_hSemaphore;       //调度线程唤起信号
    TaskContainer		m_TaskQueue;
    IdleThreadContainer	m_IdleThreadSTask;
    BusyThreadContainer	m_BusyThreadList;
};

#include "threadpoolexp.h"
#include "mythread.h"


CThreadPoolExp::CThreadPoolExp(void)
    : m_bIsExit(true)
    , m_bIsResumed(false)
    , m_iThreadNum(0)
    , m_hThread(NULL)
    , m_hSemaphore(NULL)
{
    m_hSemaphore = CreateEvent(NULL, TRUE, FALSE, NULL);
}


CThreadPoolExp::~CThreadPoolExp(void)
{
    DestroyThreadPool();
    CloseHandle(m_hSemaphore);
}

bool CThreadPoolExp::AddTask(Task *pTask, TASK_PRIORITY priority)
{
    if ( NULL == pTask )
        return false;
    if ( TASK_PRIORITY_HIGH == priority )
    {
        m_TaskQueue.PushFront(pTask);
    }
    else
    {
        m_TaskQueue.Push(pTask);
    }

    if ( !m_TaskQueue.IsEmpty() && !m_IdleThreadSTask.IsEmpty())
    {
        ResumeThread();     //唤起调度线程
    }
    return true;
}

bool CThreadPoolExp::SwitchActiveThread(MyThread *pThread)
{
    if ( m_TaskQueue.IsEmpty() )
    {
        m_BusyThreadList.RemoveThread(pThread);
        m_IdleThreadSTask.Push(pThread);
    }
    else
    {
        Task *pTask = NULL;
        pTask = m_TaskQueue.Pop();
        if ( NULL == pTask )
        {
            m_BusyThreadList.RemoveThread(pThread);
            m_IdleThreadSTask.Push(pThread);
            return true;
        }
//        OutputDebugString("pThread->AssignTask(pTask)\r\n");
        pThread->AssignTask(pTask);
        pThread->StartTask();
    }
    return true;
}

unsigned _stdcall CThreadPoolExp::ThreadProc(LPVOID lParam)
{
    CThreadPoolExp *pThreadPool = static_cast<CThreadPoolExp *>(lParam);
    pThreadPool->ManageThreads();
    return 0;
}

bool CThreadPoolExp::ManageThreads()
{
    DWORD ret = WAIT_FAILED;
    while ( true )
    {
        ret = WaitForSingleObject(m_hSemaphore, INFINITE);
        if(WAIT_OBJECT_0 == ret)
        {
            if ( m_bIsExit )
            {
                return false;
            }
            if ( m_TaskQueue.IsEmpty() )
            {
                SuspendThread();
            }
            else
            {
                MyThread *pThread = GetIdleThread();
                if ( NULL == pThread )
                {
                    SuspendThread();
                    continue;
                }
                Task *pTask = NULL;
                pTask = GetNewTask();
                if ( NULL == pTask )
                {
                    m_IdleThreadSTask.Push(pThread);
                    continue;
                }

                m_BusyThreadList.AddThread(pThread);
                pThread->AssignTask(pTask);
                pThread->StartTask();
            }
        }
    }
    return true;
}

bool CThreadPoolExp::SuspendThread()
{
    if(NULL == m_hThread)
    {
        return false;
    }
    if(!m_bIsResumed)   //已被睡眠则返回
    {
        return true;
    }
    bool  isSucceed = ResetEvent(m_hSemaphore);
    if(isSucceed)
    {
        m_bIsResumed = false;
    }
    return true;
}

bool CThreadPoolExp::ResumeThread()
{
    if(NULL == m_hThread)
    {
        return false;
    }
    if(m_bIsResumed)
    {
        return true;
    }
    bool  isSucceed = SetEvent(m_hSemaphore);
    if(isSucceed)
    {
        m_bIsResumed = true;
    }
    return true;
}

MyThread* CThreadPoolExp::GetIdleThread()
{
    if ( m_IdleThreadSTask.IsEmpty() )
        return NULL;
    return m_IdleThreadSTask.Pop();
}

Task* CThreadPoolExp::GetNewTask()
{
    if ( m_TaskQueue.IsEmpty() )
        return NULL;
    Task *pTask = NULL;
    pTask = m_TaskQueue.Pop();
    return pTask;
}

int CThreadPoolExp::SetThreadNum(int iThreadNum)
{
    m_iThreadNum = iThreadNum;
    return m_iThreadNum;
}

bool CThreadPoolExp::StartThreadPool()
{
    if ( 0 == m_iThreadNum || !IsExit() )
        return false;
    m_bIsExit = false;
    m_hThread = (HANDLE)_beginthreadex(NULL, 0, ThreadProc, this, 0, NULL);
    if ( NULL == m_hThread )
    {
        m_bIsExit = true;
        return false;
    }
    for ( int i = 0; i < m_iThreadNum; ++i )
    {
        MyThread *pThread = new MyThread(this);
        pThread->StartMyThread();
        m_IdleThreadSTask.Push(pThread);
    }

    return true;
}

bool CThreadPoolExp::DestroyThreadPool()
{
    if ( IsExit() )
        return true;
    m_bIsExit = true;
    Sleep(50);
    WaitForSingleObject(m_hThread, INFINITE);
    CloseHandle(m_hThread);
    ResetEvent(m_hSemaphore);

    m_TaskQueue.Clear();
    m_IdleThreadSTask.Clear();
    m_BusyThreadList.Clear();

    return true;
}

bool CThreadPoolExp::IsExit()
{
    return m_bIsExit;
}

#include <Windows.h>
#include <QString>

#define WIDTHBYTES(bits) (((bits) + 31) / 32 * 4)

typedef  long long int64_Cam;
typedef  int int32_Cam;
typedef	 unsigned int uint32_Cam;
typedef  unsigned long long uint64_Cam;

typedef struct  ThreadInfo
{
    ThreadInfo(QString sql, QString path, LPVOID pObject)
        :m_sSql(sql)
        ,m_sFilePath(path)
        ,m_pObject(pObject)
    {

    }
    QString		m_sSql;			//数据导出数据库查询语句
    QString     m_sFilePath;	//导出文件存储路径
    LPVOID		m_pObject;		//窗口信息输出对象

}THREAD_INFO;

enum TASK_PRIORITY
{
    TASK_PRIORITY_NORMAL,
    TASK_PRIORITY_HIGH
};

class Task;

class CMyLock
{
public:
    CMyLock() {
        InitializeCriticalSectionAndSpinCount(&m_cs, 4000);
    }
    ~CMyLock() {
        DeleteCriticalSection(&m_cs);
    }
    void Lock() {
        EnterCriticalSection(&m_cs);
        //OutputDebugString("EnterCriticalSection(&m_cs);\r\n");
    }
    void UnLock() {
        LeaveCriticalSection(&m_cs);
        //OutputDebugString("LeaveCriticalSection(&m_cs);\r\n");
    }
private:
    CRITICAL_SECTION m_cs;
};

class CMyAutoLock
{
public:
    CMyAutoLock(CMyLock *pLock) : m_pLock(pLock) {
        if ( m_pLock )
            m_pLock->Lock();
    }
    ~CMyAutoLock() {
        if ( m_pLock )
            m_pLock->UnLock();
    }
private:
    CMyLock *m_pLock;
};
#endif // TYPEDEF_H

线程池的使用：

线程函数声明：

static bool funRun(LPVOID lParam); //需线程处理的任务

线程函数定义： 
bool MyScene::funRun(LPVOID lParam)
{
    if(NULL == lParam)
    {
        return false;
    }
    THREAD_INFO *pInfo = static_cast<THREAD_INFO*>(lParam);
    if(pInfo)
    {
        qDebug()<<pInfo->m_sSql;
        qDebug()<<pInfo->m_sFilePath;
        MyScene *pMySence = static_cast<MyScene*>(pInfo->m_pObject);
        if(pMySence)
        {
            return;
        }
 

      emit pMySence->threadStarted();
 

 

 

        //do something
 

 

        delete(pInfo);//资源回收
 

        pInfo = NULL;
 

        emit pMySence->threadFinished();
 

    }
 

}
 

 

线程池的使用：
 

 

//线程池测试
 

    QString fixSql("");
 

    QString fixFilePath("");
 

    for(int i = 0; i < 10; ++i)
 

    {
 

        fixSql = tr("fixSql at:%1").arg(i);
 

        fixFilePath = tr("fixFilePath at:%1").arg(i);
 

 

        THREAD_INFO *pInfo = new THREAD_INFO(fixSql, fixFilePath, this);
 

        MyTask *pTask = new MyTask;
 

        pTask->SetTaskInfo(i, funRun, pInfo);
 

        ThreadPool::g_cThreadPoolExp->AddTask(pTask, TASK_PRIORITY_NORMAL);
 

    }
 

 

 

 

 

 

 



                

        

        

    

  


    

      

        

            

              
                
                  cLover_xiaolei
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
freertos线程池

				
			

			

				

					10-03
				

			

		

		

			
				
在stmF4上实现了线程池， 工作队列， 延时队列，周期性任务，延时任务 你无需为工程创建多少个临时线程而烦恼

			
		

	



                

              
                



	

		

			

				
					
多线程三 并发容器简单使用

				
			

			

				

					用针戳左手中指指头的博客
				

				

					04-06
					
					506
					
				

			

		

		

			
				
1.threadLocal

本地线程变量，在每个线程会独立开辟内存空间。

在高并发先不要使用。


private static ThreadLocal local = new ThreadLocal();

public static void main(String[] args) {
    new Thread(()->{
        try {
            Ti...

			
		

	



                


  
              

                


	

		

			

				
					
prometheus指标收集之pod实例、jvm

				
			

			

				

					qq_34468174的博客
				

				

					03-05
					
					5154
					
				

			

		

		

			
				
这里写自定义目录标题工作中使用kub-prometheus整理的一些指标项pod指标一、cpu/内存/负载三、网络jvm指标项
工作中使用kub-prometheus整理的一些指标项
k8s版本和prometheus版本可能会有不同，官网提供的标准指标说明，但指代的不是很明确，官方地址官网指标说明
pod指标
配置的最大内存：kube_pod_container_resource_limits_memory_bytes{namespace=“qiaofeng-namespace”,pod=“example-

			
		

	





	

		

			

				
					
Prometheus cadvisor组件监控指标概述

					
最新发布

				
			

			

				

					weixin_44545140的博客
				

				

					07-04
					
					1990
					
				

			

		

		

			
				
Prometheus cadvisor监控指标分类统揽

			
		

	



		

			
		



	

		

			

				
					
RT-Thread分析-对象容器实现与作用

				
			

			

				

					只想.静静的博客
				

				

					02-10
					
					1444
					
				

			

		

		

			
				
目录

1 前言

2 相关数据结构

2.1 对象

1）类型

2）数据结构

2.3 容器

1）数据结构

2）容器定义 _object_container[]

2.3 对象容器链接图

3 获取对象容器 rt_object_get_information()

4对象初始化 rt_object_init()

5对象删除 rt_object_delete()

6 查找对象rt_object_find()

7 总结

1 前言

在内核中，所有数据结构都视作一个对象，包括：...

			
		

	





	

		

			

				
					
【prometheus】-06 Kubernetes云原生监控之cAdvisor容器资源监控

				
			

			

				

					god_86的专栏
				

				

					09-01
					
					1085
					
				

			

		

		

			
				
【prometheus】-05 Kubernetes云原生监控之节点性能监控2021-08-30 【prometheus】-04 轻松搞定Prometheus Eureka服务发现2021...

			
		

	





	

		

			

				
					
c++ 多线程线程池 demo

				
			

			

				

					03-02
				

			

		

		

			
				
线程池是多线程编程中一个重要的概念，它能够优化系统资源的使用，提高系统的响应速度和效率。本篇文章将深入探讨C++中的线程池实现，并通过名为“OEasyPool-1.0”的示例来展示其工作原理。  线程池是预先创建并维护...

			
		

	





	

		

			

				
					
c++ 线程池

				
			

			

				

					01-10
				

			

		

		

			
				
在C++编程中，线程池是一种管理线程资源的有效方式，它可以帮助开发者优化多线程应用程序的性能，减少线程创建和销毁的开销。本文将深入探讨线程池的概念、工作原理以及如何在C++中实现一个高效的线程池。  线程池的...

			
		

	





	

		

			

				
					
线程池代码

				
			

			

				

					06-10
				

			

		

		

			
				
线程池是多线程编程中的一个重要概念，它是一种线程使用模式，通过预先创建一定数量的线程来处理任务，而不是每当有新任务提交时就创建新的线程。线程池的使用可以有效地减少系统资源的消耗，提高系统的响应速度和...

			
		

	





	

		

			

				
					
运行tomcat报Exception in thread "ContainerBackgroundProcessor[StandardEngine[Catalina]]"

					
热门推荐

				
			

			

				

					钟渊博客
				

				

					09-26
					
					2万+
					
				

			

		

		

			
				
启动tomcat报错：
Exception in thread "ContainerBackgroundProcessor[StandardEngine[Catalina]]"                                                    java.lang.OutOfMemoryError: PermGen space 
PermGen space的全

			
		

	





	

		

			

				
					
yarn中container、mr内存的配置，控制container个数

				
			

			

				

					梦，不可及，所以可期待...
				

				

					08-26
					
					1万+
					
				

			

		

		

			
				
  最近项目在用kylin，在搭建开发环境和测试环境后，然后在kylin上建cube，kylin建cube的实际就是调用集群的MR跑任务(也可以调用spark作为引擎)，在数据量小或者维度(kylin里面的一个概念)少的时候没问题，后来数据量大或维度多了，就经常出现OOM的问题。 
  其实一开始就知道是并行度过高的问题，也尝试过在kylin里面调试，但并没有用。后来通过jps查看yarnchil...

			
		

	





	

		

			

				
					
Docker 容器化技术介绍（七） 之 Docker 应用部署

				
			

			

				

					ternence_hsu的博客
				

				

					08-25
					
					2690
					
				

			

		

		

			
				
Docker 容器化技术介绍（一） 之 虚拟化技术

Docker 容器化技术介绍（二） 之 Docker 简介

Docker 容器化技术介绍（三） 之 Docker 组件

Docker 容器化技术介绍（四） 之 Docker的安装与启动

Docker 容器化技术介绍（五） 之 Docker 镜像操作

Docker 容器化技术介绍（六） 之 Docker 容器操作

Docker 容器化技...

			
		

	





	

		

			

				
					
docker 设置container 内存 和cpu 数以及查看container消耗内存

				
			

			

				

					weixin_44494773的博客
				

				

					03-31
					
					4688
					
				

			

		

		

			
				
docker 启动时限制cpu 和内存，–cpus 设置使用cpu数量 -m 设置使用内存
设置目的是为了不影响其他服务正常运行。
docker run -i -d --cpus 4 -m 12GB  -v $PWD:/celery_works/aa  image ID jupyter notebook --allow-root  --ip 0.0.0.0
备注：通过top命令查看cpu和内存使用...

			
		

	





	

		

			

				
					
Java——线程

				
			

			

				

					qq_39622795的博客
				

				

					09-06
					
					283
					
				

			

		

		

			
				
创建线程
定义+创建+启动

创建线程的第一种方式

public class Test{
	public static void main(String[] args){
		Thread thread=new Process();
		thread.start();
		for(int i=0;i<3;i++)
			System.out.println("ooo");
	}
}

class Process extends Thread{
	public void run()
	{
		for(

			
		

	





	

		

			

				
					
C++封装实用的CMyAutoLock

				
			

			

				

					海王星
				

				

					09-18
					
					331
					
				

			

		

		

			
				

#ifndef MY_LOCK_H
#define MY_LOCK_H

#include &lt;map&gt;
#include &lt;vector&gt;
#include &lt;Windows.h&gt;

//临界区
class CMyCritSection{
public:
	CMyCritSection(){
		::InitializeCriticalSection(&amp...

			
		

	





	

		

			

				
					
基于C++11的线程池

				
			

			

				

					weixin_30483013的博客
				

				

					06-14
					
					139
					
				

			

		

		

			
				
本篇系C++ socket网络爬虫（1）的姊妹篇，写网络爬虫怎么能少得了线程呢

源代码地址：http://files.cnblogs.com/magicsoar/ThreadPoolProject.rar
*需要C++11的支持,在vs2013下编译通过
运行效果


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

			
		

	





	

		

			

				
					
static  __stdcall 顺序问题

				
			

			

				

					weixin_30614587的博客
				

				

					03-02
					
					194
					
				

			

		

		

			
				
这样正确 
DWORD  static __stdcall _RecvThreadProc( PFDMRECVINFO pstRecvInfo );

反之就错误
DWORD __stdcallstatic _RecvThreadProc( PFDMRECVINFO pstRecvInfo );

谁知道为什么?
>_<   
转载于:ht...

			
		

	





	

		

			

				
					

				
			

			

				

					
				

			

		

		

			
				

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值