Linux系统

Linux多线程编程：如何等待线程结束？ (linux等待线程结束)

Linux上的多线程编程在实践中非常常见，但它也会带来一些问题。其中的一个问题是如何等待线程结束。在本文中，我们将探讨如何做到这一点以及一些注意事项。

1.线程的不同类型

在开始讨论如何等待线程结束之前，我们需要了解一些线程的基础知识。在Linux中，有几种不同类型的线程。具体来说，有用户级线程和内核级线程。用户级线程是由用户空间的线程库(DLL)实现的，而内核级线程是由操作系统内核实现的。明白了这一点，我们就可以了解到，等待线程结束有两种方法：一种是使用PTHREAD_JOIN()系统调用，另一种是使用等待(pthread_cond_wt())和通知(pthread_cond_signal())机制。

2.PTHREAD_JOIN()

PTHREAD_JOIN()系统调用是等待线程结束的一种方法。当调用这个系统调用时，当前线程会阻塞，直到指定的线程结束为止。这个系统调用的参数是要等待的线程的ID，第二个参数是线程返回值的指针。这种方法非常直观，但也有一些问题。如果我们希望在被等待的线程结束之前，当前线程也能够终止，则需要重新设置当前线程的信号处理器。此外，如果被等待的线程已经以分离(也就是说，它已经处于非joinable状态)，那么我们将无法等待它结束。

3.等待和通知(pthread_cond_wt() 和 pthread_cond_signal())

等待和通知机制是等待线程结束的另一种方法。在这种机制下，主线程将monitor结构作为监视器条件，并通过pthread_cond_wt()函数对其进行等待。被等待的线程对monitor结构进行修改，并在完成任务后，通过pthread_cond_signal()函数将等待的线程唤醒。这种方法需要使用pthread_mutex_lock()函数以获得同步访问权限，以防止竞争条件，并确保只有一个线程可以访问共享数据。

4.注意事项

无论使用哪种方法，都需要遵循一些注意事项。一定要确保在等待线程结束时，UI线程不会被阻塞。这可以通过使用非阻塞算法来实现。在使用等待和通知机制时，请确保防止竞争条件，以免导致死锁。如果可能的话，尽量将线程设计得简单明了。这样做可以让其易于维护，并减少需要等待线程结束时的工作量。

5.

无论是使用PTHREAD_JOIN()系统调用还是等待和通知机制，等待线程结束都需要仔细考虑。需要确保遵守更佳实践，避免竞争条件，以确保代码的可维护性和可靠性。如果您正确地实现了等待线程结束的机制，则可以更好地控制并发性，并提高代码的可扩展性。

相关问题拓展阅读：

C++在linux下怎么多线程

#ifndef THREAD_H_  

#define THREAD_H_  

#include   

#include   

class Runnable  

{  

public:  

//运行实体  

virtual void run() = 0;  

};  

//线程类  

class Thread: public Runnable  

{  

private:  

//线程初始化号  

static int thread_init_number;  

//当前线程初始化序号  

int current_thread_init_number;  

//线程体  

Runnable *target;  

//当前线程的线程ID  

pthread_t tid;  

//线程的状态  

int thread_status;  

//线程属性  

pthread_attr_t attr;  

//线咐唯弯程优先级  

sched_param param;  

//获取执行方法的指针  

static void* run0(void* pVoid);  

//内部执行方法  

void* run1();  

//获取线程序号  

static int get_next_thread_num();  

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 *target);  

//析构  

~Thread();  

//线程的运行体  

void run();  

//开始执行线程  

bool start();  

//获取线程状态  

int get_state();  

//等待线程直至退出  

void join();  

//等待线程退出或者超时  

void join(unsigned long millis_time);  

//比较两个线程时候相同，通过current_thread_init_number判断  

bool operator ==(const Thread* other_pthread);  

//获取this线程ID  

pthread_t get_thread_id();  

//获取当前线程ID  

static pthread_t get_current_thread_id();  

//当前线程是否和某个线程相等，通过tid判断  

static bool is_equals(Thread* iTarget);  

//设置线程的类型:绑定/非绑山型定  

void set_thread_scope(bool isSystem);  

//获取线程的类型:绑定/非绑定  

bool get_thread_scope();  

//设置线程的优先级，1－99，其中99为实时，意外的为普通  

void set_thread_priority(int priority);  

//获取线程的优先级  

int get_thread_priority();  

};  

int Thread::thread_init_number = 1;  

inline int Thread::get_next_thread_num()  

{  

return thread_init_number++;  

}  

void* Thread::run0(void* pVoid)  

{  

Thread* p = (Thread*) pVoid;  

p->run1();  

return p;  

}  

void* Thread::run1()  

{  

thread_status = THREAD_STATUS_RUNNING;  

tid = pthread_self();  

run();  

thread_status = THREAD_STATUS_EXIT;  

tid = 0;  

pthread_exit(NULL);  

}  

void Thread::run()  

{  

if (target != NULL)  

{  

  (*target).run();  

}  

}  衡闷

Thread::Thread()  

{  

tid = 0;  

thread_status = THREAD_STATUS_NEW;  

current_thread_init_number = get_next_thread_num();  

pthread_attr_init(&attr);  

}  

Thread::Thread(Runnable *iTarget)  

{  

target = iTarget;  

tid = 0;  

thread_status = THREAD_STATUS_NEW;  

current_thread_init_number = get_next_thread_num();  

pthread_attr_init(&attr);  

}  

Thread::~Thread()  

{  

pthread_attr_destroy(&attr);  

}  

bool Thread::start()  

{  

return pthread_create(&tid, &attr, run0, this);  

}  

inline pthread_t Thread::get_current_thread_id()  

{  

return pthread_self();  

}  

inline pthread_t Thread::get_thread_id()  

{  

return tid;  

}  

inline int Thread::get_state()  

{  

return thread_status;  

}  

void Thread::join()  

{  

if (tid > 0)  

{  

  pthread_join(tid,NULL);  

}  

}  

void Thread::join(unsigned long millis_time)  

{  

if (tid == 0)  

{  

  return;  

}  

if (millis_time == 0)  

{  

  join();  

}  

else  

{  

  unsigned long k = 0;  

  while (thread_status != THREAD_STATUS_EXIT && k tid;  

}  

void Thread::set_thread_scope(bool isSystem)  

{  

if (isSystem)  

{  

  pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM);  

}  

else  

{  

  pthread_attr_setscope(&attr, PTHREAD_SCOPE_PROCESS);  

}  

}  

void Thread::set_thread_priority(int priority)  

{  

pthread_attr_getschedparam(&attr,&param);  

param.__sched_priority = priority;  

pthread_attr_setschedparam(&attr,&param);  

}  

int Thread::get_thread_priority(){  

pthread_attr_getschedparam(&attr,&param);  

return param.__sched_priority;  

}  

#endif /* THREAD_H_ */

与c语言一样，使用线猛册举程库，pthread线程，例如

#include

#include

#include

struct member

{

int num;

char *name;

};

//结构体后的分号勿漏

void *create(void *arg)

//有void* 型参数传入，不能直接void

{

struct member *temp;

temp=(struct member *)arg;

//结构体变量之间不能直接赋值，但可以通过指针赋地址

printf(“member->枝碧num:%d\n”,temp->num);

printf(“member->name:%s\n”,temp->name);

sleep(1);

return (void *)8;

//这个很有特色，返回一个指向void的数据类型的值，这个值作为后面的exit code

}

int main(int agrc,char* argv)

{

pthread_t tidp;

struct member *b;

void* a;

b=(struct member *)malloc(sizeof(struct member));

//先分配内存空间撒~

b->num=1;

b->name=”mlq”;

//字符串赋值，其他好用简便的方法有： char *p = NULL; p = new char ;

if((pthread_create(&tidp,NULL,create,(void*)b))==-1) /

//

void *

为“无类型指针”，void * 可以指向任何类型的数据

{

printf(“create error!\n”);

return 1;

}

if(pthread_join(tidp,&a))

//调用

pthread_join函数，等待线程结束再继续往下执行，要不然主姿猜进程和下面的线程并行执行

{

printf(“thread is not exit…\n”);

return -2;

}

printf(“thread is exit ,code is %d\n”,(int)a);//不知为啥这里是(int)a,,a不是指针来的么

return 0;

linux如何停止线程

先看进程号，然后用KILL命令！楼上正解！

杀死线键顷程 所在的进程就可以，

ps aux | grep 进程名

kill -TERM 进程号

如果你指的斗亮帆写程序，空雹 那就参考 man pthread_exit

关于linux等待线程结束的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。


数据运维技术 » Linux多线程编程：如何等待线程结束？ (linux等待线程结束)
分享到：

相关推荐