绑定cpu的线程类封装和不绑定cpu的线程类封装

最新推荐文章于 2021-11-04 13:51:30 发布
最新推荐文章于 2021-11-04 13:51:30 发布
阅读量177 收藏
点赞数
分类专栏： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42651205/article/details/100011853
版权

绑定cpu的线程：
threadutils.h

#ifndef _THREADUTILS_H_
#define _THREADUTILS_H_

/* 使用方法
 * 创建类，继承CAbstractRunnable
 * 实现线程处理函数（可实现多个）void *run1(struct SThreadInfo* pThreadInfo);
 * 注册处理函数REGIST_RUN_FUNC(A,run1),A为类名，run1为处理函数，如下：
    class A : public CAbstractRunnable
    {
        ...
        public:
        void *run1(struct SThreadInfo *pThreadInfo);
        void *run2(struct SThreadInfo *pThreadInfo);
        REGIST_RUN_FUNC(A,run1)
        REGIST_RUN_FUNC(A,run2)
        ...
    };
    实例化类
    A a;
    启动线程
    CThreadUtils::createThreadOnCore(&a, a.GET_RUN_FUNC(run1), 0, 1);
    CThreadUtils::createThreadOnCore(&a, a.GET_RUN_FUNC(run2), 1, 1);
 */
#ifdef WIN32
#include <windows.h>
#else
#include <pthread.h>
#include <errno.h>
#endif

#include <string>
#include <vector>
#include <unistd.h>
#include <stdio.h>

#define THREADUTILS_PRIORITY_LOW 0
#define THREADUTILS_PRIORITY_NORMAL 1
#define THREADUTILS_PRIORITY_HIGH 2


class CAbstractRunnable;

typedef void* (*PRUNNABLE_FUNC)(void*);

//每创建一个线程都维护一个线程相关信息
struct SThreadInfo
{
#ifdef WIN32
    HANDLE hThread;
#else
    pthread_t hThread;      //线程句柄
#endif
    int bRunning;       //运行状态
    int bWatch;         //是否监护
    int coreId;         //绑定cpu
    CAbstractRunnable *pRunObj; //线程运行对象
    PRUNNABLE_FUNC pRunFunc;    //线程执行的任务
    void *arg;
};
class CAbstractRunnable
{
public:
    #define REGIST_RUN_FUNC(ClassName, FuncName) \
        static void* STATIC_##FuncName(void *lParam){ \
            struct SThreadInfo *pThreadInfo = (struct SThreadInfo*)lParam; \
            ClassName *p = (ClassName*)pThreadInfo->pRunObj; \
            return p->FuncName(pThreadInfo); \
        }

    #define GET_RUN_FUNC(FuncName) STATIC_##FuncName

    bool bShouldStop;
    int sleepInterval;

    CAbstractRunnable();

    virtual std::string& getObjectName() = 0;
    int isShouldStop();
    void setShouldStop(int bShouldStop);
    int isRunning();
    void startThread();
    void stopThread();
    void idleProcess();
};

class CThreadUtils
{
private:
    static std::vector<struct SThreadInfo*> ThreadInfoList;
public:
    static int createThreadOnCore(CAbstractRunnable *pObject, PRUNNABLE_FUNC pFunc, int coreId, int bWatch, void *arg=NULL);
    static int restartThread(struct SThreadInfo *pThreadInfo);
    static void watcher();
    static void startWatcherThread();
    static void sleep(unsigned int ms);
    static int setPriority(unsigned int value, int type);
    static int showPriority();
    static int setThreadAffinityMask(unsigned int pid);
    static int getCpuNum();
    static int isObjRunning(CAbstractRunnable *pObj);
    static void startObj(CAbstractRunnable *pObj);
    static void stopObj(CAbstractRunnable *pObj);
    static void stopAll();
};
typedef CThreadUtils ThreadUtils;


#endif

threadutils.cpp

#include "threadutils.h"
#ifndef WIN32
#include <signal.h>
#endif


std::vector<struct SThreadInfo*> CThreadUtils::ThreadInfoList;

#ifndef WIN32
void *ThreadMain(void *lpParam)
#else
DWORD __stdcall ThreadMain(void *lpParam)
#endif
{
    struct SThreadInfo *pa = (struct SThreadInfo *)lpParam;
    if(pa->coreId!=-1)
        CThreadUtils::setThreadAffinityMask(pa->coreId);
    pa->bRunning = 1;
    pa->pRunObj->bShouldStop = 0;
    pa->pRunFunc(lpParam);
    pa->bRunning = 0;
    return 0;
}

CAbstractRunnable::CAbstractRunnable()
{
    bShouldStop = true;
    sleepInterval = 10;
}

int CAbstractRunnable::isShouldStop()
{
    return bShouldStop;
}

int CAbstractRunnable::isRunning()
{
    return CThreadUtils::isObjRunning(this);
}

void CAbstractRunnable::startThread()
{
    CThreadUtils::startObj(this);
}

void CAbstractRunnable::stopThread()
{
    CThreadUtils::stopObj(this);
}

void CAbstractRunnable::setShouldStop(int bShouldStop)
{
    this->bShouldStop = bShouldStop;
}

void CAbstractRunnable::idleProcess()
{
    CThreadUtils::sleep(sleepInterval);
}

//启动线程
int CThreadUtils::createThreadOnCore(CAbstractRunnable *pRunObj,
            PRUNNABLE_FUNC pFunc,
            int coreId,
            int bWatch,
            void *arg)
{
    SThreadInfo *pThreadInfo = new SThreadInfo();
    pThreadInfo->bRunning = 0;
    pThreadInfo->bWatch = bWatch;
    pThreadInfo->coreId = coreId;
    pThreadInfo->pRunObj = pRunObj;
    pThreadInfo->pRunFunc = pFunc;
    pThreadInfo->arg = arg;

#ifdef WIN32
    pThreadInfo->hThread = CreateThread(
        NULL,       // no security attributes 
        0,          // use default stack size  
        ThreadMain, // thread function 
        (LPVOID)pThreadInfo,    // argument to thread function ,this object pointer
        0,          //CREATE_SUSPENDED, // use default creation flags 
        NULL);      // returns the thread identifier
    if (pThreadInfo->hThread == NULL)
    {
        printf("createThreadOnCore failured, object=%s core=%d\n",
            pThreadInfo->pRunObj->getObjectName().c_str(), pThreadInfo->coreId);
        return -1;
    }
    return 0;
#else
    int iRet;
    iRet = pthread_create(
        &pThreadInfo->hThread,      //thread id
        NULL,           //thread attr
        ThreadMain,     //thread function 
        (void *)pThreadInfo);   //argumet to thread function ,this object pointer
    if (iRet != 0 )
    {
        printf("createThreadOnCore failured object=%s core=%d\n",
            pThreadInfo->pRunObj->getObjectName().c_str(), pThreadInfo->coreId);
        delete pThreadInfo;
        return -1;
    }
    else
    {
        printf("createThreadOnCore success object=%s core=%d\n",
            pThreadInfo->pRunObj->getObjectName().c_str(), pThreadInfo->coreId);
        ThreadInfoList.push_back(pThreadInfo);
        return 0;
    }
#endif
}

//重启线程
int CThreadUtils::restartThread(struct SThreadInfo *pThreadInfo)
{
#ifdef WIN32
    pThreadInfo->hThread = CreateThread(
        NULL,       // no security attributes 
        0,          // use default stack size  
        ThreadMain, // thread function 
        (LPVOID)pThreadInfo,    // argument to thread function ,this object pointer
        0,          //CREATE_SUSPENDED, // use default creation flags 
        NULL);      // returns the thread identifier
    if (pThreadInfo->hThread == NULL)
    {
        printf("restartThreadOnCore failured object=%s core=%d\n",
            pThreadInfo->pRunObj->getObjectName().c_str(), pThreadInfo->coreId);
        return -1;
    }
    return 0;
#else
    int iRet;
    iRet = pthread_create(
        &pThreadInfo->hThread,      //thread id
        NULL,           //thread attr
        ThreadMain,     //thread function 
        (void *)pThreadInfo);   //argumet to thread function ,this object pointer
    if (iRet != 0 )
    {
        printf("restartThreadOnCore failure object=%s core=%d\n",
            pThreadInfo->pRunObj->getObjectName().c_str(), pThreadInfo->coreId);
        return -1;
    }
    else
    {
        printf("restartThreadOnCore success object=%s core=%d\n",
            pThreadInfo->pRunObj->getObjectName().c_str(), pThreadInfo->coreId);
        return 0;
    }
#endif
}

//线程看护
void CThreadUtils::watcher()
{
    std::vector<SThreadInfo*>::iterator it;

    while(1)
    {
        for(it=ThreadInfoList.begin(); it!=ThreadInfoList.end(); it++)
        {
            if(!(*it)->bWatch)
                continue;
            if((*it)->pRunObj->bShouldStop)
                continue;
#ifdef WIN32
            DWORD ExitCode;
            if(!GetExitCodeThread((*it)->hThread, &ExitCode)) continue;
            if(ExitCode != STILL_ACTIVE)
#else
            if( pthread_kill((*it)->hThread,0) == ESRCH )
#endif
            {
                (*it)->bRunning = 0;
                printf("Thread %s was exit on core %d, restart now\n",
                    (*it)->pRunObj->getObjectName().c_str(), (*it)->coreId);
                CThreadUtils::restartThread(*it);
                CThreadUtils::sleep(1);
            }
        }
        CThreadUtils::sleep(5000);
    }
}

//启看护线程
#ifdef WIN32
void CThreadUtils::startWatcherThread()
{
    HANDLE hd = CreateThread(
        NULL,       // no security attributes 
        0,          // use default stack size  
        (DWORD(__stdcall*)(void*))CThreadUtils::watcher,    // thread function 
        NULL,   // argument to thread function ,this object pointer
        0,          //CREATE_SUSPENDED, // use default creation flags 
        NULL);      // returns the thread identifier
    if (hd == NULL)
    {
        printf("can not create thread watcher thread\n");
        return;
    }
}
#else
void CThreadUtils::startWatcherThread()
{
    pthread_t pid;
    if(0!=pthread_create(&pid, NULL, (void*(*)(void*))CThreadUtils::watcher, NULL))
    {
        printf("can not create thread watcher thread\n");
        return;
    }
}
#endif

void CThreadUtils::sleep(unsigned int ms)
{
#ifdef WIN32
    Sleep(ms);
#else
    ms *=1000;
    usleep(ms);
#endif
}

//设置线程优先级
int CThreadUtils::setPriority(unsigned int value, int type)
{
#ifdef WIN32
    u_int32_t priority = THREAD_PRIORITY_NORMAL;
    if(value == THREADUTILS_PRIORITY_LOW)
        priority = THREAD_PRIORITY_LOWEST;
    else if(value == THREADUTILS_PRIORITY_HIGH)
        priority = THREAD_PRIORITY_HIGHEST;
    int bSucc = SetThreadPriority(GetCurrentThread(), priority);
    if(!bSucc)
    {
        return -1;
    }
#else
    int rs;
    /*SCHED_FIFO优先级策略 */
    struct sched_param param;
    if(value == THREADUTILS_PRIORITY_LOW)
        param.__sched_priority = sched_get_priority_min(type);//(SCHED_FIFO/*SCHED_RR*/);
    else if(value == THREADUTILS_PRIORITY_HIGH)
        param.__sched_priority = sched_get_priority_max(type);//(SCHED_FIFO/*SCHED_RR*/);
    else
        param.__sched_priority = (sched_get_priority_min(type)+sched_get_priority_max(type))/2;

    rs = sched_setscheduler(0, type,&param);
    if(rs != 0 )
    {
        return -1;
    }
#endif
    return 0;
}

//查询线程优先级
int CThreadUtils::showPriority()
{
#ifdef WIN32
    int level;
    level = GetThreadPriority(GetCurrentThread());
    printf("policy level:%d\n",GetThreadPriority(GetCurrentThread()));
    return level;
#else
    int policy, ret;
    struct sched_param param;
    ret = pthread_getschedparam(pthread_self(), &policy, &param);
    if(ret!=0)
        perror("pthread_getschedparam:");
    else
    {
        if (policy == SCHED_FIFO)
            printf("policy:SCHED_FIFO, ");
        else if (policy == SCHED_OTHER)
            printf("policy:SCHED_OTHER, ");
        else if (policy == SCHED_RR)
            printf("policy:SCHED_RR, ");
        else printf("policy: UNKNOW, ");
            printf("policy level:%d\n", param.sched_priority);
    }
    return ret;
#endif
}

//绑定cpu逻辑核
int CThreadUtils::setThreadAffinityMask(unsigned int pid)
{
#ifdef WIN32
    u_int32_t val = 1 << pid;
    u_int32_t hr= SetThreadAffinityMask(GetCurrentThread(), val);
    if(hr == 0)
    {
        printf("setThreadAffinityMask %u failure\n", val);
        return -1;
    }
#else
    // CPU binding in linux, pid=0 express to bind current thread
    int ret;
    cpu_set_t mask;
    CPU_ZERO(&mask);
    int len = sizeof(mask);
    ret = sched_getaffinity(0, len, &mask);
    if (ret == -1)
    {
        printf("sched_getafinity failed!\n");
        return -1;
    }

    CPU_ZERO(&mask);
    CPU_SET(pid, &mask);
    ret = sched_setaffinity(0, len, &mask);
    if (ret == -1)
    {
        printf("sched_setaffinity failed!\n");
        return -1;
    }
#endif
    return 0;
}

//获取逻辑核个数
int CThreadUtils::getCpuNum()
{
    int cpuNum = 0;

#ifdef WIN32
    SYSTEM_INFO sysInfo;
    GetSystemInfo(&sysInfo);
    cpuNum = sysInfo.dwNumberOfProcessors;
#else
    cpuNum = sysconf(_SC_NPROCESSORS_ONLN);
#endif

    return cpuNum;
}

int CThreadUtils::isObjRunning(CAbstractRunnable *pObj)
{
    std::vector<SThreadInfo*>::iterator it;

    printf("start thread object=%s...\n", pObj->getObjectName().c_str());

    for(it=ThreadInfoList.begin(); it!=ThreadInfoList.end(); it++)
    {
        if( (*it)->pRunObj != pObj )
            continue;
        if((*it)->bRunning)
            return 1;
    }

    return 0;
}

//启动某对象所有线程
void CThreadUtils::startObj(CAbstractRunnable *pObj)
{
    std::vector<SThreadInfo*>::iterator it;

    printf("start thread object=%s...\n", pObj->getObjectName().c_str());

    for(it=ThreadInfoList.begin(); it!=ThreadInfoList.end(); it++)
    {
        if( (*it)->pRunObj != pObj )
            continue;
        if((*it)->bRunning)
        {
            printf("one thread is already running, can not restart\n");
            continue;
        }
        restartThread(*it);
        sleep(1);
    }
}

//结束某对象线程
void CThreadUtils::stopObj(CAbstractRunnable *pObj)
{
    std::vector<SThreadInfo*>::iterator it;

    printf("stop thread object=%s...\n", pObj->getObjectName().c_str());

    for(it=ThreadInfoList.begin(); it!=ThreadInfoList.end(); it++)
    {
        if( (*it)->pRunObj != pObj )
            continue;
        (*it)->pRunObj->bShouldStop = 1;
        break;
    }

    sleep(2000);

    for(it=ThreadInfoList.begin(); it!=ThreadInfoList.end(); it++)
    {
        if( (*it)->pRunObj != pObj )
            continue;
#ifdef WIN32
        DWORD dwExitCode = 0;
        TerminateThread((*it)->hThread, dwExitCode);
#else
        pthread_cancel((*it)->hThread);
#endif
        (*it)->bRunning = 0;
    }
}

//结束所有线程
void CThreadUtils::stopAll()
{
    std::vector<SThreadInfo*>::iterator it;

    printf("stop all thread...\n");

    for(it=ThreadInfoList.begin(); it!=ThreadInfoList.end(); it++)
    {
        (*it)->pRunObj->bShouldStop = 1;
    }

    sleep(2000);

    for(it=ThreadInfoList.begin(); it!=ThreadInfoList.end(); it++)
    {
#ifdef WIN32
        DWORD dwExitCode = 0;
        TerminateThread((*it)->hThread, dwExitCode);
#else
        pthread_cancel((*it)->hThread);
#endif
        (*it)->bRunning = 0;
    }
    sleep(1000);

    int i;
    for(i=0; i<ThreadInfoList.size(); i++)
    {
        if(ThreadInfoList[i])
        {
            delete ThreadInfoList[i];
            ThreadInfoList[i] = NULL;
        }
    }
    ThreadInfoList.clear();
}


/***

class A : public CAbstractRunnable
{
public:
    void *run1(struct SThreadInfo *pThreadInfo);
    void *run2(struct SThreadInfo *pThreadInfo);
    REGIST_RUN_FUNC(A,run1)
    REGIST_RUN_FUNC(A,run2)
};

class B : public CAbstractRunnable
{
public:
    void *run1(struct SThreadInfo *pThreadInfo);
    void *run2(struct SThreadInfo *pThreadInfo);
    REGIST_RUN_FUNC(B,run1)
    REGIST_RUN_FUNC(B,run2)
};

void * A::run1(struct SThreadInfo *pThreadInfo)
{
    printf("A::runn1() is running...\n");
    sleep(15);
}

void * A::run2(struct SThreadInfo *pThreadInfo)
{
    printf("A::runn2() is running...\n");
    sleep(10);
}

void * B::run1(struct SThreadInfo *pThreadInfo)
{
    printf("B::runn1() is running...\n");
    sleep(20);
}

void * B::run2(struct SThreadInfo *pThreadInfo)
{
    printf("B::runn2() is running...\n");
    sleep(20);
}

int main()
{
    A a;
    B b;
    A *pa;
    pa = &a;
    
    CThreadUtils::createThreadOnCore(&a, a.GET_RUN_FUNC(run1), 0, 1);usleep(100000);
    CThreadUtils::createThreadOnCore(&a, a.GET_RUN_FUNC(run2), 1, 1);usleep(100000);
    CThreadUtils::createThreadOnCore(&b, b.GET_RUN_FUNC(run1), 2, 1);usleep(100000);
    CThreadUtils::createThreadOnCore(&b, b.GET_RUN_FUNC(run2), 3, 1);usleep(100000);
    CThreadUtils::createThreadOnCore(pa, pa->GET_RUN_FUNC(run1), 4, 1);usleep(100000);

    //CThreadUtils::watcher();
    CThreadUtils::startWatcherThread();

    while(1) sleep(1);
    
    return 0;
}
***/

不绑cpu，简单的线程封装
threadutl.h

#ifndef _CTHREAD_H
#define _CTHREAD_H

#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include <stdlib.h>

class CZthread
{
public:
    CZthread();
    virtual ~CZthread();
    int mutexInit(pthread_mutex_t* mutexlock);
    int mutexLock(pthread_mutex_t* mutexlock);
    int mutexUnlock(pthread_mutex_t* mutexlock);
    int mutexDestroy(pthread_mutex_t* mutexlock);
    //int getThreadNumber(void);
    //void setThreadNumber(int threadNumber);
    pthread_t start();
    virtual void run() = 0;
    void stop();
protected:
    bool bRun;
    //int m_threadNumber;
    //pthread_mutex_t m_mutex;
};

#endif

threadutl.cpp

#include "zthread.h"

CZthread::CZthread()
{
    bRun = true;
    //m_threadNumber = 1;
}

CZthread::~CZthread()
{
    stop();
}

static void* actionRun(void* param)
{
    CZthread* pt = (CZthread*)param;
    pt->run();
    return NULL;
}

int CZthread::mutexInit(pthread_mutex_t* mutexlock)
{
    return pthread_mutex_init(mutexlock, NULL);
}

int CZthread::mutexLock(pthread_mutex_t* mutexlock)
{
    return pthread_mutex_lock(mutexlock);
}

int CZthread::mutexUnlock(pthread_mutex_t* mutexlock)
{
    return pthread_mutex_unlock(mutexlock);
}

int CZthread::mutexDestroy(pthread_mutex_t* mutexlock)
{
    return pthread_mutex_destroy(mutexlock);
}

#if 0
int CZthread::getThreadNumber(void)
{
    return this->m_threadNumber;
}

void CZthread::setThreadNumber(int threadNumber)
{
    this->m_threadNumber = threadNumber;
}
#endif

pthread_t CZthread::start()
{
#if 1
    pthread_t id;
    if (pthread_create(&id, NULL, actionRun, this) != 0)
        std::cerr << "线程创建失败，线程号=" << id << std::endl;

    return id;
#endif
#if 0
    pthread_t pthread[this->m_threadNumber];
    for (int i = 1; i <= this->m_threadNumber; i++)
    {
        if (pthread_create(&pthread[i], NULL, actionRun, this) != 0)
        {
            std::cerr << "线程创建失败，线程号=" << i << std::endl;
        }
    }

    for (int i = 1; i <= this->m_threadNumber; i++)
    {
        if (pthread_join(pthread[i], NULL) != 0)
        {
            std::cerr << "线程执行失败，线程号=" << i << std::endl;
        }
    }
#endif
}

void CZthread::stop()
{
    bRun = false;
}

test.cpp

#include "threadutl.h"
#include <string.h>
#include <iostream>
class CTest : public CZthread
{
public:
    CTest() { inum = 10; }
    void run()
    {
        for (int i = 0; i < inum; i++)
        {
            std::cout << i << std::endl;
        }
    }
private:
    int inum;
};

int main(int argc, char** argv)
{
    std::string strmd5;
    //CContentCheck::instance()->getFileMd5("./bin/ftpdir/tn.mp3", strmd5);
    CTest *ts = new CTest();
    ts->setThreadNumber(2);
    ts->start();

    int i;
    while(i < 10000)
        i++;
    return 0;
}
一定迟到逗
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ThreadUtils
04-24
链式android线程切换工具类
linux 线程的绑定 PTHREAD_SCOPE_SYSTEM（绑定的）和PTHREAD_SCOPE_PROCESS（非绑定的）
LBO4031的专栏
05-18 7497
详情:http://baike.baidu.com/view/400319.htm 关于线程的绑定，牵涉到另外一个概念：轻进程（LWP：Light Weight Process）。轻进程可以理解为内核线程，它位于用户层和系统层之间。系统对线程资源的分配、对线程的控制是通过轻进程来实现的，一个轻进程可以控制一个或多个线程。默认状况下，启动多少轻进程、哪些轻进程来控制哪些线程是由系统来控制的，这
window下Socket和线程封装
03-01
程序功能如下： 1、对UDP Socket进行封装； 2、接收和发送用同一个端口； 3、采用线程阻塞式接收；...4、程序清晰命了，集合Socket和线程封装，可以用来参考 ---因为同是UDP，则不能重复绑定，所以只能一次。
多线程控件绑定
12-26
多线程绑定控件的封装,避免绑定过程中出现窗体假死的现象,可以在一定程度上提高用户体验
java线程简单的封装类
06-11
用反射实现了对java线程简单的封装，类似c#线程，使用此封装类勿需再次继承Thread类或实现Runnable接口，直接绑定需要使用线程的方法即可，另支持动态传参，如觉着好用请多多支持作者 QQ 359103820 希望能为使用线程...
使用IOCP完成端口和SOCKET封装的成熟异步TCP类
01-18
使用IOCP完成端口和SOCKET...线程创建和事件信号量等地方用到了MFC的类，如果项目不支持MFC，可以把这些地方替换成WindowsAPI的方式。 代码是从成熟项目中分离出来的，能达到很高的性能和网络吞吐量，并且稳定无BUG。
Java面试题-面向对象、多线程.pdf
03-17
- 封装：通常认为封装是把数据和操作数据的方法绑定起来， 对数据的访问只能通过已定义的接口。面向对象的本质就是 将现实世界描绘成一系列完全自治、封闭的对象。 我们在类中编写的方法就是对实现细节的一种封装...
Java线程池的五种使用方式源代码ThreadPoolUtils
08-09
Java线程池的五种使用方式源代码ThreadPoolUtils, 包含五种不同线程池的创建和使用，以及错误处理机制和线程示例
线程工具类ThreadUtils
weixin_30412167的博客
02-04 550
package yqw.java.util; public class ThreadUtils { /** * showThreadInfo * * @return */ public static final String showThreadInfo() { return "^^^^^^^^^^^^^^^^^^^^^^^ cu...
java thread 工具_线程工具类ThreadUtils
weixin_34307029的博客
02-21 58
package yqw.java.util;public class ThreadUtils {/*** showThreadInfo** @return*/public static final String showThreadInfo() {return "^^^^^^^^^^^^^^^^^^^^^^^ currentThread: name=" + Thread.currentThread...
common-lang3.ThreadUtils
Q563573095的博客
03-06 567
一、代码书写规范 1、每个功能一个方法，保存方法的原子性。 2、每个方法都要有前置校验，确保入参满足方法运行需求。 3、对于不满足运行条件的异常要抛出运行时异常，如前置校验。 4、方法中不同的功能单元要隔一行。 5、方法中调用有多个入参的方法，每个参数要独占一行以便于调试。 6、检查异常一般是为了恢复考虑的。 7、在调用时，如果底层方法有前置校验，那调用方就不用校验了。 8、方法注...
ThreadUtils线程工具类
京北游戏官方
11-04 909
package com.rc.openapi.util; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.concurrent.CountDownLatch; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class ThreadU
（二十九）Java工具类ThreadUtils详解
OceanSky的专栏
02-13 2551
前言：ThreadUtils是对于java.lang.Thread和java.lang.ThreadGroup的扩展和帮助； 1.构造函数 public ThreadUtils() {} 分析：ThreadUtils 实例不应该在标准的应用程序中构建，相反，这个类应该使用ThreadUtils.getAllThreads()，此构造函数是公开的，允许使用JavaBean实例操作的工具； ...
线程锁定CPU linux,linux 线程与CPU绑定
weixin_34952710的博客
05-12 331
看到很多程序都是根据CPU个数来创建线程个数，当时很不理解他们之间的关系，请教了项目组的同事后才有了大致了解。1. 相关系统函数下面的函数可以通过man命令查询到。SYNOPSIS#define _GNU_SOURCE#include int pthread_setaffinity_np(pthread_t thread, size_t cpusetsize,const cpu_set_t *cp...
和我说说以下内容：1面向对象程序设计的基本特征 2类与对象的区别 3构造方法的特点 4变量的种类及作用域 5传值和传引用 6Static 及运行程序的过程 7包的作用 8静态绑定和动态绑定概念，并能根据静态绑定和动态绑定的基本原理来理解程序的运行结果 9多态的实现 10通过类、抽象类、接口实现UML语言描述的类、抽象类、接口。 11能区别异常处理中catch和finally语句。 12 线程(重点):定义、多线程、临界资源，如何访问临界资源。 13 java操作数据库：JDBC
最新发布
06-06
变量包括局部变量、成员变量和类变量。局部变量是在方法或代码块中定义的变量，作用域仅限于该方法或代码块。成员变量是在类中定义的变量，作用域是整个类。类变量是用static关键字定义的变量，作用域是整个类，可以...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值