关于多线程以及其访问类的成员函数

最新推荐文章于 2023-04-19 21:34:27 发布
最新推荐文章于 2023-04-19 21:34:27 发布
阅读量1.5k 收藏 1
点赞数
CC 4.0 BY-SA版权
分类专栏： Linux多线程编程 文章标签： 多线程 null delete join
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/tianmohust/article/details/7279573
本文介绍了如何在C/C++中使用多线程和指针函数来传递参数，并通过实例展示了如何访问类成员函数。文章包括了多线程创建、线程间通信以及指针函数在类成员访问中的应用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

一 一般的多线程传递参数的程序

#include <stdio.h>
#include <pthread.h>

//gcc -lpthread -o cpro cpro.c

void *test(void *p)
{
	int *a = (int *)p;
	printf("num = %d\n",*a);
}
int main()
{
	int a = 5;

	int *p = &a;

	pthread_t id;

	pthread_create(&id,NULL,(void*)test, p);

	pthread_join(id,NULL);

	return 0;
}

二 使用指针函数访问类的成员函数 

#include <stdio.h>
#include <pthread.h>
#include <iostream>
//g++ -lpthread -o cpro cpro.cpp
class triangle
{
	private:
		int length;
		int width;
		int height;

	public:
		triangle();
		virtual ~triangle();
		static void displayFirst(triangle *pthis);
		void display();
};

triangle::triangle()
{
	length = 2;
	width  = 3;
	height = 4;
}
void triangle::display()
{
	printf("%d,%d,%d\n",length,width,height);
}
void triangle::displayFirst(triangle *pthis)
{
	pthis->display();
}
triangle::~triangle()
{
}

void *midCall(triangle * tri)
{
	triangle::displayFirst(tri);
}
int main()
{
//pthread_t id;

triangle *tri = new triangle;

typedef void (*nPtr)(triangle *);//自定义指针函数
nPtr p;
p = (nPtr)triangle::displayFirst;
p(tri);

//pthread_create(&id,NULL,(void *)midCall,tri);

//pthread_join(id,NULL);

delete tri;

return 0;
}
#include <stdio.h>
#include <pthread.h>
#include <iostream>

class triangle
{
	private:
		int length;
		int width;
		int height;

	public:
		triangle();
		virtual ~triangle();
		static void displayFirst(triangle *pthis);
		void display();
};

triangle::triangle()
{
	length = 2;
	width  = 3;
	height = 4;
}
void triangle::display()
{
	printf("%d,%d,%d\n",length,width,height);
}
void triangle::displayFirst(triangle *pthis)
{
	pthis->display();
}
triangle::~triangle()
{
}

void *midCall(void *)
{
	//printf("a = %d\n",*a);
	triangle *tri = new triangle;
	triangle::displayFirst(tri);
	delete tri;
}
int main()
{
	pthread_t id;

	//int a = 9;
	//int *p = &a;

	pthread_create(&id,NULL,midCall,NULL);

	pthread_join(id,NULL);	

	return 0;
}
#include <stdio.h>
#include <pthread.h>
#include <iostream>

class triangle
{
	private:
		int length;
		int width;
		int height;

	public:
		triangle();
		virtual ~triangle();
		static void displayFirst(triangle *pthis);
		void display();
};

triangle::triangle()
{
	length = 2;
	width  = 3;
	height = 4;
}
void triangle::display()
{
	printf("%d,%d,%d\n",length,width,height);
}
void triangle::displayFirst(triangle *pthis)
{
	pthis->display();
}
triangle::~triangle()
{
}

void *midCall(void *arg)
{
	triangle *tri = (triangle *)arg;
	//triangle::displayFirst(tri);
	tri->display();
	
}
int main()
{
	pthread_t id;
	
	triangle *tri = new triangle;
	
	pthread_create(&id,NULL,midCall,(void *)tri);//must be the type of the void pointer.
	pthread_join(id,NULL);	
	
	delete tri;
	
	return 0;
}
#include <stdio.h>
#include <pthread.h>
#include <iostream>
//g++ -lpthread -o cpro cpro.cpp
class triangle
{
	private:
		int length;
		int width;
		int height;

	public:
		triangle();
		virtual ~triangle();
		static void displayFirst(triangle *pthis);
		void display();
};

triangle::triangle()
{
	length = 2;
	width  = 3;
	height = 4;
}
void triangle::display()
{
	printf("%d,%d,%d\n",length,width,height);
}
void triangle::displayFirst(triangle *pthis)
{
	pthis->display();
}
triangle::~triangle()
{
}

void *midCall(void *arg)
{
	triangle *tri = (triangle *)arg;
	triangle::displayFirst(tri);
	
}
int main()
{
	pthread_t id;
	
	triangle *tri = new triangle;
	
	pthread_create(&id,NULL,midCall,(void *)tri);//must be the type of the void pointer.
	pthread_join(id,NULL);	
	
	delete tri;
	
	return 0;
}

#ifndef UNISE_THREAD_H_
#define UNISE_THREAD_H_

#include <cstdlib>
#include <errno.h>
#include <pthread.h>
#include <string>

#include "unise/base.h"

namespace unise
{

/// @brief 简单线程处理逻辑的封装基类，用户仅需要实现 run 接口。
/// @note 支持一些基本的线程操作接口。如果需要对线程运行进行较为复杂的操作，
/// 建议不要直接使用此基类。
class Thread
{
public:
    Thread(const std::string& name):
        _tid(0), _name(name) {
    }

    virtual ~Thread() {
    }

    /// @brief 获取线程名
    /// @return
    const std::string& get_name() {
        return _name;
    }

    /// @brief 获取线程id
    /// @return 线程的 thread id
    pthread_t get_tid() {
        return _tid;
    }

    /// @brief 强制取消线程对象对应的线程的执行
    /// @return 与 pthread_cancel 返回语义相同
    int cancel() {
        int ret = ESRCH;
        if (0 != _tid) {
            ret = pthread_cancel(_tid);
            if (0 != ret) {
                UWARNING("[\tlvl=FOLLOW\t] FAIL: pthread_cancel(name=%s, tid=%d) return %d",
                        get_name().c_str(), _tid, ret);
            } else {
                _tid = 0;
            }
        }
        return ret;
    }

    /// @brief 给线程发送一个信号
    /// @note 这个操作保证信号处理函数在对应线程的上下文中执行，但可能影响整个进程。
    /// @return 与 pthread_kill 返回语义相同
    int kill(int sig = SIGTERM) {
        int ret = ESRCH;
        if (0 != _tid) {
            ret = pthread_kill(_tid, sig);
            if (0 != ret) {
                UWARNING("[\tlvl=FOLLOW\t] FAIL: pthread_kill(name=%s, tid=%d, signal=%d) "
                            "return %d", get_name().c_str(), _tid, sig, ret);
            } else {
                _tid = 0;
            }
        }
        return ret;
    }

    /// @brief 将线程分离，使其自己处理回收资源。
    /// @return
    virtual int detach() {
        int ret = ESRCH;
        if (0 != _tid) {
            ret = pthread_detach(_tid);
            if (0 != ret) {
                UWARNING("[\tlvl=FOLLOW\t] FAIL: pthread_detach(name=%s, tid=%d) return %d",
                        get_name().c_str(), _tid, ret);
            }
        }
        return ret;
    }

    /// @brief 调用该函数join本线程
    /// @return
    virtual int join() {
        int ret = ESRCH;
        if (0 != _tid) {
            ret = pthread_join(_tid, NULL);
            if (0 != ret) {
                UWARNING("[\tlvl=FOLLOW\t] FAIL: pthread_join(name=%s, tid=%d) return %d",
                        get_name().c_str(), _tid, ret);
            } else {
                _tid = 0;
            }
        }
        return ret;
    }

    /// @brief 子类实现该函数以自定义线程函数
    /// @return
    virtual int run() = 0;

    /// @brief 调用该函数启动线程
    /// @return 与 pthread_create 的返回值含义相同
    virtual int start() {
        UTRACE("Start thread(%s).", get_name().c_str());
        int ret = pthread_create(&_tid, NULL, _run_thread, (void *)this);
        if (0 != ret) {
            UWARNING("[\tlvl=FOLLOW\t] FAIL: pthread_create(name=%s) return %d",
                        get_name().c_str(), ret);
        }
        return ret;
    }

protected:
    /// @brief 退出线程，在run函数中调用，不应该在外部调用。
    /// @param[in] p 退出参数，返回给 join 调用的信息
    void exit(void *p) {
        if (0 != get_tid()) {
            pthread_exit(p);
        }
    }

private:

    /// @brief 线程函数,就是在pthread_create传入的函数
    /// @param[in|out] para : 用于传入给线程处理的数据
    /// @return
    static void* _run_thread(void *para) {
        com_openlog_r();    // 不检查返回值
        Thread *t = reinterpret_cast<Thread*>(para);
        UNOTICE("Thread(name=%s, tid=%d) running.", t->get_name().c_str(),
                t->get_tid());
        int ret = t->run();
        UNOTICE("Thread(name=%s, tid=%d) exit, return %d", t->get_name().c_str(),
                t->get_tid(), ret);
        com_closelog_r();
        return NULL;
    }

private:
    pthread_t   _tid;       ///< 线程ID
    std::string _name;      ///< 线程名
};

}   // namespace unise

#endif

c++多线程与静态成员函数的实例
希望我的博客，能帮上你解决学习中工作中所遇到的问题
05-23 564
c++多线程与静态成员函数的实例 #include <thread> #include <iostream> using namespace std; // 4.Non-static member function class Base { public: static void fun(int x) { while (x-- > 0) { cout << x << endl; }
C++类成员函数在多线程中的一些问题研究
Rachelint的博客
05-10 1986
之前只在C语言下，利用pthread搞过一些小demo玩。看实验室并行框架源码时发觉，全是C++风格的多线程，涉及到的pthread_create()为何不能以成员函数作为参数、锁成员变量、线程安全的类各种的问题，这些之前完全没有接触过。特此进行了两天的调研和思考，现在就简单整理一下这两天看过的资料。 由于就真的是光看没练，只是单纯翻了一堆大致原理，可能会有不少纰漏。阅读后觉得有不妥的地方，那很可能就真的是不妥的，笑。 1. C++类成员函数在内存中的摆法 之前转载了一篇文章，文中大致介绍C++类成员函数在
c++ 多线程 类成员函数_实战经验：通过类成员函数指针实现类方法调用
weixin_40008566的博客
11-23 293
问题在开发中，有时候可能需要使用到类成员指针来调用类的方法。例如，可能会有一个函数调用表格，根据不同的情况调用表格中不同的类成员函数。今天使用一个简单的例子来讲述如何使用类成员函数指针。类成员函数指针定义因为函数是一个类的成员，所以它的指针定义有别于全局函数，格式如下：typedef 返回值(类名::*函数指针类型名称)(参数列表);需要注意的地方1) 使用typedef创建一个用户自定义类型，这...
创建多线程API调用类成员函数的方式
miraclewgf的博客
07-19 505
在熟悉多线程编程过程中，在做demo是需要在创建多线程时将类成员函数作为参数，以下是方法，总结如下：   创建多线程时直接用类成员函数的函数指针作为参数是不可以的，只能是static静态成员函数才可以，因此需要多写一个static成员函数，将类的指针作为参数传进来用来封装一下。   类的成员函数声明如下： class thread_t { public:         ~thre
多线程中成员函数的调用
小金的想法
01-21 1049
在创建线程的时候使用成员函数，只能使用静态的成员函数。今天看到别人的一个写法觉得比较灵活，先贴上来。class A{ static DWORD WINAPI StartThread(LPVOID pParam) { A *parent = (A*) pParam; switch(parent->state) { case 0: parent
多线程调用类的成员函数的实现
tianmo2010的专栏
02-21 3558
该方法实现了多线程灵活的调用类的成员函数。代码如下： #include #include #include //g++ -lpthread -o cpro cpro.cpp class triangle { private: int length; int width; int height; public: triangle(); virtual ~tri
C++ 线程函数是类的成员函数
05-09
3. **线程函数作为成员函数**：将线程函数定义为类的成员，可以方便地访问类的私有数据，无需通过额外的同步机制（如锁）来保护数据，因为线程函数和数据在同一作用域内，天然具备了访问权限。 二、创建线程成员...
python 对类的成员函数开启线程的方法
09-19
- 在创建线程时，如果成员函数需要访问类的其他属性或方法，则必须通过`self`传递实例。 - 使用`join`方法等待所有线程完成，避免主线程提前退出导致子线程被强制终止。 - 考虑到Python的全局解释器锁（GIL）问题，...
关于C++静态成员函数访问非静态成员变量的问题
09-04
在某些情况下，如多线程编程，静态成员函数用于创建线程函数是很常见的，因为线程函数通常需要是静态的。线程函数通常需要一个入口点，这个入口点不依赖于特定的对象实例，但可能需要访问类的成员。在这种情况下，...
c++ 多线程调用类成员函数方法
start223的博客
04-29 7126
main.cpp #include <iostream> #include <thread> using namespace std; class print { public: void printHello(string name) { cout<<"Hello "<<name<<"!!!\n"; } }; int main(int argc, char **argv) { print
C++线程池/线程工具
04-08
1：可以使用类成员函数/全局函数单独的创建一个线程。 2：可以使用类成员函数/全局函数单独的为线程池添加一个任务,可以带多个参数。 3：线程池的线程数量可手动扩展，稍作修改可以修改为自动扩充。 是否下载可前往https://blog.youkuaiyun.com/j506825719/article/details/79846763查看博客后再做决定
类内成员函数 多线程调用 调试记录
weixin_30586257的博客
07-25 219
最近工程上需要用到多线程调用类内成员函数，记录一下当时出错的问题，及解决方法。 1.首先 写法是普通多线程调用时候的声明，如下： void getRegResultByOneSetpThread(const int decodeType, vector<vector<float>>& probAll, ...
用线程函数来访问一个类
浪的专栏
08-26 725
用线程函数来访问一个类 用线程函数来访问一个类(即将线程函数做成成员函数的方法)1.先定义一个线程函数（在要访问的类的头文件顶部添加）  如:UINT ThreadFun(LPVOID pParam);2.然后在定义一个线程时将线程函数和一个this绑定,如:（要创建线程的位置添加）CWinThread * pThread=AfxBeginThread(       ThreadFun,/
用于同步对多个对象的多线程访问的类
寒冰屋的专栏
04-19 100
在此技巧中，我将共享一个小类，该类将多线程访问同步到多个对象。
【C++】多线程中调用函数的方法
horizon_ys的博客
02-14 3625
在多线程中调用函数的方法： 以函数名和函数参数作为输入对象来构造线程对象：t2 t4 t6 t7 通过lambda表达式调用函数，将函数作为lambda表达式的内容: t1 t3 t5 #include <iostream> #include <thread> #include <string> void printAll(int a, int b, int c) { std::cout << a << " " << b &l
多线程访问一个类与 类之间的协作联系
iteye_5797的博客
06-23 178
多线程访问一个类，是对一个类中的实例变量进行访问，需要进行互责保护。相同的一个线程类同时访问一个类。 多个类之间进行协同工作，也可能是多个类访问某一个类，改变它的实例变量。 对象存在与堆上。...
【笔记】C++ 多线程：进程同时创建5个线程，各自调用同一个函数；线程调用的函数在一个类中，且应将该函数声明为静态成员函数；进程创建时设置pthread_attr_t属性及join功能；互斥锁的实现
nyist_yangguang的博客
01-11 3001
注： os:ubuntu 10.04 c++ 1. 进程同时创建5个线程，各自调用同一个函数 #include <iostream> #include <pthread.h> //多线程相关操作头文件，可移植众多平台 using namespace std; #define NUM_THREADS 5 //线程数 void* say_hello( void* args ) { cout << "hello..." << en..
一种在线程函数里面访问类成员的方法
tangaowen的专栏
05-03 1744
   在有些时候，我们要新开一个线程，在这个线程里面要访问到类的成员函数和成员变量，但是CreateThread函数要求提供的线程函数必须是静态成员函数或者全局函数，这样在线程里面是不能够访问到类的成员变量的。这就是一个比较麻烦的矛盾。     一种解决方案：将对象的this指针作为参数传递给线程函数，然后在线程函数里面将其转换为相应的类对象指针，在里面调用指针进行相应的操作就OK了。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值