关于Linux 系统下 C++ 的多线程基类 Thread

最新推荐文章于 2024-02-22 11:00:23 发布
最新推荐文章于 2024-02-22 11:00:23 发布
阅读量1.4k 收藏 2
点赞数
分类专栏： linux 文章标签： linux 多线程 c++
最近在Linux 下用C++做的东西，原来是使用“多进程”方式实现，现在随着工程的增大，“多进程”的“变量共享”问题已经十分突出了，虽然可以使“内存共享”等方式实现，但大量的“内存共享”会导致代码混乱。。
所以决心将整个工程重新写，使用“多线程”方式实现，这样可以大大较少“内存共享”的使用次数。

下面是我写的基类，把代码保存在名为 Thread.h 的头文件中。
====================================传说中的分割线================================= 
/* 
 * File:   Thread.h
 * Author: Null
 * Blog: http://hi.baidu.com/hetaoos
 * Created on 2008年7月30日, 上午10:13
 */

/*
 * 在编译的时候记得加上参数：-lpthread
 * 
 */

#ifndef _THREAD_H
#define _THREAD_H


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

class Thread
{
private:
    //当前线程的线程ID
    pthread_t tid;
    //线程的状态
    int threadStatus;
    //获取执行方法的指针
    static void* run0(void* pVoid);
    //内部执行方法
    void* run1();
public:
    //线程的状态－新建
    static const int THREAD_STATUS_NEW = 0;
    //线程的状态－正在运行
    static const int THREAD_STATUS_RUNNING = 1;
    //线程的状态－运行结束
    static const int THREAD_STATUS_EXIT = -1;
    //构造函数
    Thread();
    //线程的运行实体
    virtual void run() = 0;
    //开始执行线程
    bool start();
    //获取线程ID
    pthread_t getThreadID();
    //获取线程状态
    int getState();
    //等待线程直至退出
    void join();
    //等待线程退出或者超时
    void join(unsigned long millisTime);
};

void* Thread::run0(void* pVoid)
{
    Thread* p = (Thread*) pVoid;
    p->run1();
    return p;
}

void* Thread::run1()
{

    threadStatus = THREAD_STATUS_RUNNING;
    tid = pthread_self();
    run();
    threadStatus = THREAD_STATUS_EXIT;
    tid = 0;
    pthread_exit(NULL);
}

Thread::Thread()
{
    tid = 0;
    threadStatus = THREAD_STATUS_NEW;
}

bool Thread::start()
{
    return pthread_create(&tid, NULL, run0, this) == 0;
}

pthread_t Thread::getThreadID()
{
    return tid;
}

int Thread::getState()
{
    return threadStatus;
}

void Thread::join()
{
    if (tid > 0)
    {
        pthread_join(tid, NULL);
    }
}

void Thread::join(unsigned long millisTime)
{

    if (tid == 0)
    {
        return;
    }
    if (millisTime == 0)
    {
        join();
    }else
    {
        unsigned long k = 0;
        while (threadStatus != THREAD_STATUS_EXIT && k <= millisTime)
        {
            usleep(100);
            k++;
        }
    }
}
#endif /* _THREAD_H */

====================================传说中的分割线=================================
用法简单类似于 Java 的 Thread，继承 Thread 类，然后重写 void run() 方法，然后用 bool start () 方法开始运行。这样完全屏蔽掉了线程的具体操作。使用简单方便。

具体看下面的示例代码。
====================================传说中的分割线================================= 
/*
 * File:   newmain.cc
 * Author: Null
 * Blog: http://hi.baidu.com/hetaoos
 * Created on 2008年7月30日, 上午11:49
 */


#include "Thread.h"
#include <iostream.h>

class MultiThread : public Thread
{
public:

    void run()
    {
        int number = 0;
        for (int i = 0; i < 10; i++)
        {
            cout << "Current number is " << number++;
            cout << " PID is " << getpid() << " TID is " << getThreadID() << endl;
            sleep(1);
        }
    }
};


int main(int argc, char** argv)
{
    bool ret;
    MultiThread *mt;
    mt = new MultiThread();
    ret = mt->start();
    mt->join(6000);
    return (EXIT_SUCCESS);
}
====================================传说中的分割线=================================
上面的代码，由于 join 设置超时为 6 秒，所以没能完全打印出10条记录就已经退出了。

上面的代码还有些不足：
1，���有线程属性的设置，这个当初也考虑过，但是有些麻烦，也很少用。如果哪位大侠实现了比较完成的 Thread 类，麻烦发个给我。

2，线程的控制有待完善，这个阿，暂时没有时间研究。linux


在原来的基础上，进行了加强，使之进一步接近 Java 中 Thread 和 Runnable 的用法。

下面是我写的基类，把代码保存在名为 Thread.h 的头文件中。
====================================传说中的分割线=================================

/* 
 * File:   Thread.h
 * Author: Null
 * Blog: http://hi.baidu.com/hetaoos
 * Created on 2008年7月30日, 上午10:13
 */

/*
 * 在编译的时候记得加上参数：-lpthread
 * 
 */

#ifndef _THREAD_H
#define _THREAD_H


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

/*
 * 线程运行实体类
 */
class Runnable
{
public:
    //运行实体
    virtual void run() = 0;
};

/*
 * 线程类
 *
 */
class Thread : public Runnable
{
private:
    //线程初始化序号
    static int threadInitNumber;
    //当前线程初始化序号
    int curThreadInitNumber;
    //线程体
    Runnable *target;
    //当前线程的线程ID
    pthread_t tid;
    //线程的状态
    int threadStatus;
    //线程属性
    pthread_attr_t attr;
    //线程优先级
    sched_param param;
    //获取执行方法的指针
    static void* run0(void* pVoid);
    //内部执行方法
    void* run1();
    //获取一个线程序号
    static int getNextThreadNum();

public:
    //线程的状态－新建
    static const int THREAD_STATUS_NEW = 0;
    //线程的状态－正在运行
    static const int THREAD_STATUS_RUNNING = 1;
    //线程的状态－运行结束
    static const int THREAD_STATUS_EXIT = -1;
    //构造函数
    Thread();
    //构造函数
    Thread(Runnable *iTarget);
    //析构
    ~Thread();
    //线程的运行实体
    void run();
    //开始执行线程
    bool start();
    //获取线程状态
    int getState();
    //等待线程直至退出
    void join();
    //等待线程退出或者超时
    void join(unsigned long millisTime);
    //比较两个线程时候相同,通过 curThreadInitNumber 判断
    bool operator ==(const Thread *otherThread);
    //获取This线程ID
    pthread_t getThreadID();
    //获取当前线程ID
    static pthread_t getCurrentThreadID();
    //当前线程是否和某个线程相等,通过 tid 判断
    static bool isEquals(Thread *iTarget);
    //设置线程的类型:绑定/非绑定
    void setThreadScope(bool isSystem);
    //获取线程的类型:绑定/非绑定
    bool getThreadScope();
    //设置线程的优先级,1-99,其中99为实时;意外的为普通
    void setThreadPriority(int priority);
    //获取线程的优先级
    int getThreadPriority();
};

int Thread::threadInitNumber = 1;

inline int Thread::getNextThreadNum()
{
    return threadInitNumber++;
}

void* Thread::run0(void* pVoid)
{
    Thread* p = (Thread*) pVoid;
    p->run1();
    return p;
}

void* Thread::run1()
{

    threadStatus = THREAD_STATUS_RUNNING;
    tid = pthread_self();
    run();
    threadStatus = THREAD_STATUS_EXIT;
    tid = 0;
    pthread_exit(NULL);
}

void Thread::run()
{
    if (target != NULL)
    {
        (*target).run();
    }
}

Thread::Thread()
{
    tid = 0;
    threadStatus = THREAD_STATUS_NEW;
    curThreadInitNumber = getNextThreadNum();
    pthread_attr_init(&attr);
}

Thread::Thread(Runnable *iTarget)
{
    target = iTarget;
    tid = 0;
    threadStatus = THREAD_STATUS_NEW;
    curThreadInitNumber = getNextThreadNum();
    pthread_attr_init(&attr);
}

Thread::~Thread()
{
    pthread_attr_destroy(&attr);
}

bool Thread::start()
{
    return pthread_create(&tid, &attr, run0, this) == 0;
}

inline pthread_t Thread::getCurrentThreadID()
{
    return pthread_self();
}

inline pthread_t Thread::getThreadID()
{
    return tid;
}

inline int Thread::getState()
{
    return threadStatus;
}

void Thread::join()
{
    if (tid > 0)
    {
        pthread_join(tid, NULL);
    }
}

void Thread::join(unsigned long millisTime)
{

    if (tid == 0)
    {
        return;
    }
    if (millisTime == 0)
    {
        join();
    }else
    {
        unsigned long k = 0;
        while (threadStatus != THREAD_STATUS_EXIT && k <= millisTime)
        {
            usleep(100);
            k++;
        }
    }
}

bool Thread::operator ==(const Thread *otherThread)
{
    if (otherThread == NULL)
    {
        return false;
    }
    if (curThreadInitNumber == (*otherThread).curThreadInitNumber)
    {
        return true;
    }
    return false;
}

bool Thread::isEquals(Thread *iTarget)
{
    if (iTarget == NULL)
    {
        return false;
    }
    return pthread_self() == iTarget->tid;
}

void Thread::setThreadScope(bool isSystem)
{
    if (isSystem)
    {
        pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM);
    }else
    {
        pthread_attr_setscope(&attr, PTHREAD_SCOPE_PROCESS);
    }
}

bool Thread::getThreadScope()
{
    int scopeType = 0;
    pthread_attr_getscope(&attr, &scopeType);
    return scopeType == PTHREAD_SCOPE_SYSTEM;
}

void Thread::setThreadPriority(int priority)
{
    pthread_attr_getschedparam(&attr, &param);
    param.__sched_priority = priority;
    pthread_attr_setschedparam(&attr, &param);
}

int Thread::getThreadPriority()
{
    pthread_attr_getschedparam(&attr, &param);
    return param.__sched_priority;
}
#endif /* _THREAD_H */
====================================传说中的分割线=================================


具体看下面的示例代码。
呵呵，用法和 Java 的 Thread 很相似吧。
下面一共生成了3个线程，3个线程都共享 MultiThread::run()
在 run() 里面通过判断线程的实体来分离各个线程的工作。

====================================传说中的分割线================================= 
/* 
 * File:   newmain.cc
 * Author: Null
 * Blog: http://hi.baidu.com/hetaoos
 * Created on 2008年7月30日, 上午12:49
 */


#include "Thread.h"
#include <iostream.h>

class MultiThread : public Thread
{
public:

    Thread *th1;
    Thread *th2;

    void Test()
    {
        th1 = new Thread(this);
        th1->setThreadPriority(99);
        th2 = new Thread(this);
        start();
        th1->start();
        th2->start();
        th1->join();
        th2->join();
    }

    void run()
    {
        //Thread->isEquals(th1)
        if (Thread::isEquals(th1))
        {
            int number = 100;
            for (int i = 0; i < 10; i++)
            {
                cout << "this is thread1 number is " << number++;
                cout << " \tpid is " << getpid() << " tid is " << getCurrentThreadID() << "  Priority:" << th1->getThreadPriority() << endl;
                sleep(1);
            }
        }else if (Thread::isEquals(th2))
        {
            int number = 200;
            for (int i = 0; i < 10; i++)
            {
                cout << "this is thread2 number is " << number++;
                cout << " \tpid is " << getpid() << " tid is " << getCurrentThreadID() << "  Priority:" << th2->getThreadPriority() << endl;
                sleep(1);
            }
        }else if (Thread::isEquals(this))
        {
            int number = 300;
            for (int i = 0; i < 10; i++)
            {
                cout << "this is thread0 number is " << number++;
                cout << " \tpid is " << getpid() << " tid is " << getCurrentThreadID() << "  Priority:" << this->getThreadPriority() << endl;
                sleep(1);
            }
        }

    }
};

/*
 * 
 */
int main(int argc, char** argv)
{
    bool ret;
    MultiThread *mt;
    mt = new MultiThread();
    mt->Test();
    return (EXIT_SUCCESS);
}
====================================传说中的分割线=================================

PS：
1，还没有进行深入的测试，使用之前请进行必要的测试，以确保它符合你的要求。
2，如果你发现了 BUG，请联系我。 linux

wjs1033
关注
专栏目录
C++多线程编程之thread类详解
weixin_44479862的博客
11-26 1714
C++多线程编程之thread类详解
c++11&14-多线程专题
cpp加油站的专栏
07-18 872
在C++11以前，C++的多线程编程均需依赖系统或第三方接口实现，一定程度上影响了代码的移植性。C++11中，引入了boost库中的多线程部分内容，形成C++标准，形成标准后的boost多线程编程部分接口基本没有变化，这样方便了以前使用boost接口开发的使用者切换使用C++标准接口，很容易把boost接口升级为C++标准接口。 我们通过如下几部分介绍C++11多线程方面的接口及使用方法。 1. ...
C++多线程基类C++多线程基类C++多线程基类
09-07
C++多线程基类C++多线程基类C++多线程基类C++多线程基类C++多线程基类C++多线程基类C++多线程基类C++多线程基类C++多线程基类
C++ 线程基类
xupeng1644的博客
06-05 1482
这里简单实现了一个线程基类，其中未包括线程关闭的方法，等待后续添加。 XThread.h #pragma once #include <thread> class XThread { public: XThread() = default; virtual ~XThread() = default; public: virtual void Run() = 0; // 必须被子类实现，本身不能被实例化 public: void Start(); // 线程启动函数 privat
C++ 多线程
Last Order
01-04 655
本篇博客主要介绍C++ 的多线程机制。 多线程是多任务处理的一种特殊形式，多任务处理允许让电脑同时运行两个或两个以上的程序。一般情况下，两种类型的多任务处理：基于进程和基于线程。 基于进程的多任务处理是程序的并发执行。 线程的多任务处理是同一程序的片段的并发执行。 多线程程序包含可以同时运行的两个或多个部分。这样的程序中的每个部分称为一个线程，每个线程定义了
linux系统C++多线程
卡尼_Hu
04-27 622
最近接触c++多线程，在这记录一下遇到的问题： (1)编译方面： 线程头文件包含#include ，并在编译时添加-lpthread选项来链接线程库。 (2)线程创建函数： int pthread_create(pthread_t  *thread, pthread_attr_t  *attr,  void  *(*start_routine)(void  *),  void  *arg)
简单的线程基类
龙宇网的专栏
05-18 3745
 typedef unsigned (WINAPI *PTHREADFUN)(LPVOID lpParameter);class CThread{public: CThread(void) {} ~CThread(void) {} void Start(void); void Stop(void) const { CloseHandle(m_hThread); } static D
Linux C/C++线程基类源代码
02-21
总结来说，这个“Linux C/C++线程基类”源代码项目提供了一个便捷的线程管理框架，使得在Linux环境下使用C++进行多线程编程变得更加简单和直观。通过理解和利用这个基类，开发者可以专注于业务逻辑，而无需关心底层...
线程基类的设计示例代码
09-29
本文将深入探讨如何设计一个线程基类，尤其关注于Linux环境下的实现。首先，我们需要理解线程的概念以及在C++11及更高版本中对线程支持的基础知识。 在C++11引入了`<thread>`库，提供了`std::thread`类来创建和管理...
Linux 下 c++ 类内使用多线程 std::thread
qq_18076309的博客
11-01 474
Linux 下 c++ 类内使用多线程 std::thread。
Linux C++ 服务器之线程池 C++11
11-09
基于Linux平台，C++开发，socket服务器之线程池，使用thread，同步利用mutex和condition_variable实现
Linux C++11——多线程类thread
YBAdiam的博客
03-10 4639
一、并发和并行 1、并行(parallel) 指在同一时刻，有多条指令在多个处理器上同时执行。就好像两个人各拿一把铁锨在挖坑，一小时后，每人一个大坑。所以无论从微观还是从宏观来看，二者都是一起执行的。 2、并发(concurrency) 指在同一时刻只能有一条指令执行，但多个进程指令被快速的轮换执行，使得在宏观上具有多个进程同时执行的效果，但在微观上并不是同时执行的，只是把时间分成若干段，使多个进程快速交替的执行。这就好像两个人用同一把铁锨，轮流挖坑，一小时后，两个人各挖一个小一点的坑，要想挖两
C++ Linux多线程
最新发布
谢谢大家的关注
02-22 567
由于进程中的所有线程共享该进程的信号，所以线程库将根据线程掩码决定把信号发送给哪个具体的线程。这两点都说明，我们应该定义一个专门的线程来处理所有的信号。这个互斥锁可能被加锁了，但并不是由调用fork函数的那个线程锁住的，而是由其他线程锁住的。函数来回收其他线程( 前提是目标线程是可回收的，见后文)，即等待其他线程结束，这类似于回收进程的wait和waitpid系统调用。这两个函数的第一个参数分别用于设置线程的取消状态(是否允许取消)和取消类型(如何取消)，第二个参数则分别记录线程原来的取消状态和取消类型。
Linux系统下C++多线程编程
花姑的博客
01-19 1523
2017-0924 C++编译运行2017-0924 记录运行时间1、C++编译运行Linux下，C++可执行文件： *.out编译：  C++：  g++ ex1.cpp -o ex1  （ex1.cpp 为源文件，名字后缀名随意，ex1为可执行性文件，默认为.out文件，后缀名省略）           C语言： gcc ex1.c -o ex1运行： ./ex1批处理： ./ex1&&./e
C++ thread编程（Linux系统为例）—thread成员函数与thread的创建方法
qaaaaaaz的博客
05-21 1620
c++ 11 之后有了标准的线程库：std::thread。
Linux C++多线程编程
krais_wk的博客
07-17 3489
1.介绍 　　使用多线程的理由之一是和进程相比，它是一种非常”节俭”的多任务操作方式。我们知道，在Linux系统下，启动一个新的进程必须分配给它独立的地址空间，建立众多的数据表来维护它的代码段、堆栈段和数据段，这是一种”昂贵”的多任务工作方式。而运行一个进程中的多个线程，它们彼此之间使用相同的地址空间，共享大部分数据，启动一个线程所花费的空间远远小于启动一个进程，而且，线程间彼此切换所需的时间也...
Linux下C++的多线程编程
hithink的专栏
04-27 464
1、 引言 　  　线程（thread）技术早在60年代就被提出，但真正应用多线程到操作系统中去，是在80年代中期，solaris是这方面的佼佼者。传统的Unix也支持线程的概念，但是在一个进程（process）中只允许有一个线程，这样多线程就意味着多进程。现在，多线程技术已经被许多操作系统所支持，包括Windows/NT，当然，也包括Linux。 　　为什么有了进程的概念后，还要再引入线程呢
Linux C++的多线程编程
m0_74282605的博客
01-29 1043
线程（thread）技术早在60年代就被提出，但真正应用多线程到操作系统中去，是在80年代中期，solaris是这方面的佼佼者。传统的Unix也支持线程的概念，但是在一个进程（process）中只允许有一个线程，这样多线程就意味着多进程。现在，多线程技术已经被许多操作系统所支持，包括Windows/NT，当然，也包括Linux。为什么有了进程的概念后，还要再引入线程呢？使用多线程到底有哪些好处？什么的系统应该选用多线程？我们首先必须回答这些问题。使用多线程的理由之一是和进程相比，它是一种非常"节俭"的多任务
c++线程类 linux,C++进阶学习——线程基类的设计（Linux）
weixin_28689729的博客
05-06 234
此示例是在Linux环境下(使用Linux系统编程线程相关函数)测试，文件说明如下：ThreadBase.cpp, ThreadBase.h为线程基类ThreadDerive.cpp, ThreadDerive.h为测试派生类main.cpp为测试程序ThreadBase.h内容如下：#ifndef __THREADBASE_H__#define __THREADBASE_H__#include ...
C++2011标准草案详解：内存模型与多线程
1. **多线程支持**：C++11引入了`<thread>`库，允许开发者创建并管理线程，支持并发和多任务执行。同时，标准库中还包含了互斥量（mutex）、条件变量（condition_variable）等同步原语，以防止数据竞争。 2. **...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值