Hi, 请登录     我要注册     找回密码
当前位置：国外主机测评 - 国外VPS，国外服务器，国外云服务器，测评及优惠码 技术分享 正文

「Linux」子线程不阻塞主线程：如何实现？ (linux子线程如何不阻塞主线程)

2024-02-21 分类：技术分享

Linux子线程不阻塞主线程：如何实现？

在编程中，多线程技术能够很好地提高程序的效率，使得程序能够更快地响应用户的操作。然而在使用多线程技术时，会遇到一些线程之间相互阻塞的问题，这会影响程序的运行效率。本文将介绍如何实现在Linux环境下，子线程不阻塞主线程的方法。

一、 什么是子线程不阻塞主线程

在许多情况下，主线程在等待子线程结束时，会被子线程阻塞。这样会导致主线程执行的时间变长，导致程序的效率下降。因此，如果子线程能够在主线程不阻塞的情况下执行，那么就可以大大提高程序的效率。

二、 如何实现子线程不阻塞主线程

在Linux环境下，实现子线程不阻塞主线程有多种方法，下面分别介绍。

1. 使用非阻塞I/O

使用非阻塞I/O是Linux下实现子线程不阻塞主线程的一种方法。非阻塞I/O的方式是在I/O调用时告诉操作系统，不要强制等待I/O操作的完成，而是立即返回。这种方式能够使得主线程在等待I/O时，不会被阻塞，从而达到子线程不阻塞主线程的效果。

2. 使用多线程编程框架

使用多线程编程框架也是一种比较常见的方法。其中比较流行的多线程编程框架有OpenMP和Pthreads。使用多线程编程框架可以让程序执行更加高效。

3. 使用信号量机制

使用信号量机制也是Linux下实现子线程不阻塞主线程的一种方式。信号量是一个计数器，用来实现进程之间的同步和互斥。主线程可以在需要的地方挂起等待子线程发出的信号，从而实现子线程不阻塞主线程。

以上三种方法在实现子线程不阻塞主线程方面都有很好的效果，可以根据实际情况选择使用。

三、 结束语

在编写程序时，使用多线程技术可以提高程序的效率，但是线程间的阻塞问题也需要引起足够的注意。在Linux环境下，使用非阻塞I/O、多线程编程框架和信号量机制都可以实现子线程不阻塞主线程的效果。我们应该在实际应用中根据需求选择适当的方法来解决线程间的阻塞问题，从而使得程序更加高效。

相关问题拓展阅读：

  • linux怎么查看线程阻塞原因
  • Linux多进程和线程同步的几种方式

linux怎么查看线程阻塞原因

linux查看线程阻塞原因：

pthread_join

一般肆正衡主线程来调用，用来等待子线程退出，因为是等待，所以是阻塞的，一般主线程会依次join所有它创建的子线程。

1)执行top命令，或使用裂做-H选项(显示所有线程)，找到相关的高CPU的PID。

2)生成thread dump

快照

(kill -3 PID)。

3)将top命令输出PID转换为HEX格式(

16进制

)。

4)在thread dump data中搜索nid=。

5)分析受影响的thread和stack trace，精确定位代码。

特点：

Linux，全称GNU/Linux，是一套免费使用和自由传播的类Unix操作系统，是一个基于POSIX的多用户、多任务、支持

多线程

和多CPU的操作系统。伴随着互联网的发展，Linux得到了来自全世界软件爱好者、组织、公司的支持。

它除了在服务器方面保持着强劲的发展势头以外，在个人电脑、

嵌入式系统

上都有着长足的进步。使用者不仅可以直观地获取该操作系统的实现机制，而且可以根据自身的需要来修改完善Linux，使其更大化地适应用户的需要。 

Linux不仅系统性能稳定，而且是

开源软件

。其核心防火墙组件性能高效、配置简单，保证了系统的安全。在很多企业网络中，为了追求速度和安全清敏，Linux不仅仅是被网络运维人员当作服务器使用，甚至当作网络防火墙，这是Linux的一大亮点。 

Linux具有

开放源码

、没有版权、技术社区用户多等特点，开放源码使得用户可以自由裁剪，灵活性高，功能强大，成本低。尤其系统中内嵌网络

协议栈

，经过适当的配置就可实现路由器的功能。这些特点使得Linux成为开发路由交换设备的理想开发平台。

Linux多进程和线程同步的几种方式

Linux 线程同步的橘蚂笑三种方法

线程的更大特点是资源的共享性，但资源共享中的同步问题是多线程编程的难点。linux下提供了多种方式来处理线程同步，最常用的是互斥锁、条件变量和信号量。

一、互斥锁(mutex)

通过锁机制实现线程间的同步。

初始化锁。在Linux下，线程的互斥量数据类型是pthread_mutex_t。在使用前,要对它进行初始化。

静态分配：pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

动态分配：int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutex_attr_t *mutexattr);

加锁。对共享资源的访问，要对互斥量进行加锁，如果互斥量已经上了锁，调用线程会阻塞，直到互斥量被解锁。

int pthread_mutex_lock(pthread_mutex *mutex);

int pthread_mutex_trylock(pthread_mutex_t *mutex);

解锁。在完成了对共享资源的访问后，要对互斥量进行解锁。

int pthread_mutex_unlock(pthread_mutex_t *mutex);

销毁锁。锁在是使用完成后，需要进行销毁以释放资源。

int pthread_mutex_destroy(pthread_mutex *mutex);

view plain copy

#include

#include

#include

#include

#include “iostream”

using namespace std;

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

int tmp;

void* thread(void *arg)

{

cout

#include

#include “stdlib.h”

#include “unistd.h”

pthread_mutex_t mutex;

pthread_cond_t cond;

void hander(void *arg)

{

free(arg);

(void)pthread_mutex_unlock(&mutex);

}

void *thread1(void *arg)

{

pthread_cleanup_push(hander, &mutex);

while(1)

{

printf(“thread1 is running\n”);

pthread_mutex_lock(&mutex);

pthread_cond_wait(&cond, &mutex);

printf(“thread1 applied the condition\n”);

pthread_mutex_unlock(&mutex);

sleep(4);

}

pthread_cleanup_pop(0);

}

void *thread2(void *arg)

{

while(1)

{

printf(“thread2 is running\n”);

pthread_mutex_lock(&mutex);

pthread_cond_wait(&cond, &mutex);

printf(“thread2 applied the condition\n”);

pthread_mutex_unlock(&mutex);

sleep(1);

}

}

int main()

{

pthread_t thid1,thid2;

printf(“condition variable study!\n”);

pthread_mutex_init(&mutex, NULL);

pthread_cond_init(&cond, NULL);

pthread_create(&thid1, NULL, thread1, NULL);

pthread_create(&thid2, NULL, thread2, NULL);

sleep(1);

do

{

pthread_cond_signal(&cond);

}while(1);

sleep(20);

pthread_exit(0);

return 0;

}

view plain copy

#include

#include

#include “stdio.h”

#include “stdlib.h”

static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;

static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

struct node

{

int n_number;

struct node *n_next;

}*head = NULL;

static void cleanup_handler(void *arg)

{

printf(“Cleanup handler of second thread./n”);

free(arg);

(void)pthread_mutex_unlock(&mtx);

}

static void *thread_func(void *arg)

{

struct node *p = NULL;

pthread_cleanup_push(cleanup_handler, p);

while (1)

{

//这个mutex主要是用来保证pthread_cond_wait的并发性

pthread_mutex_lock(&mtx);

while (head == NULL)

{

//这个while要特别说明一下，单个pthread_cond_wait功能很完善，为何

//这里要有一个while (head == NULL)呢？因为pthread_cond_wait里的线

//程可能会被意外唤醒，如果这个时候head != NULL，则不是我们想要的情况。

//这个时候，应该让线程继续进入pthread_cond_wait

// pthread_cond_wait会先解除之前的pthread_mutex_lock锁定的mtx，

//然后阻塞在等待对列里休眠，直到再次被唤醒(大多数情况下是等待的条件成立

//而被唤醒，唤醒后，该进程会先锁定先pthread_mutex_lock(&mtx);，再读取资源

//用这个流程是比较清楚的

pthread_cond_wait(&cond, &mtx);

p = head;

head = head->n_next;

printf(“Got %d from front of queue/n”, p->n_number);

free(p);

}

pthread_mutex_unlock(&mtx); //临界区数据操作完毕，释放互斥锁

}

pthread_cleanup_pop(0);

return 0;

}

int main(void)

{

pthread_t tid;

int i;

struct node *p;

//子线程会一直等待资源，类似生产者和消费者，但是这里的消费者可以是多个消费者，而

//不仅仅支持普通的单个消费者，这个模型虽然简单，但是很强大

pthread_create(&tid, NULL, thread_func, NULL);

sleep(1);

for (i = 0; i n_number = i;

pthread_mutex_lock(&mtx); //需要操作head这个临界资源，先加锁，

p->n_next = head;

head = p;

pthread_cond_signal(&cond);

pthread_mutex_unlock(&mtx); //解锁

sleep(1);

}

printf(“thread 1 wanna end the line.So cancel thread 2./n”);

//关于pthread_cancel，有一点额外的说明，它是从外部终止子线程，子线程会在最近的取消点，退出

//线程，而在我们的代码里，最近的取消点肯定就是pthread_cond_wait()了。

pthread_cancel(tid);

pthread_join(tid, NULL);

printf(“All done — exiting/n”);

return 0;

}

三、信号量(sem)

如同进程一样，线程也可以通过信号量来实现通信，虽然是轻量级的。信号量函数的名字都以”sem_”打头。线程使用的基本信号量函数有四个。

信号量初始化。

int sem_init (sem_t *sem , int pshared, unsigned int value);

这是对由sem指定的信号量进行初始化，设置好它的共享选项(linux 只支持为0，即表示它是当前进程的局部信号量)，然后给它一个初始值VALUE。

等待信号量。给信号量减1，然后等待直到信号量的值大于0。

int sem_wait(sem_t *sem);

释放信号量。信号量值加1。并通知其他等待线程。

int sem_post(sem_t *sem);

销毁信号量。我们用完信号量后都它进行清理。归还占有的一切资源。

int sem_destroy(sem_t *sem);

view plain copy

#include

#include

#include

#include

#include

#include

#define return_if_fail(p) if((p) == 0){printf (“:func error!/n”, __func__);return;}

typedef struct _PrivInfo

{

sem_t s1;

sem_t s2;

time_t end_time;

}PrivInfo;

static void info_init (PrivInfo* thiz);

static void info_destroy (PrivInfo* thiz);

static void* pthread_func_1 (PrivInfo* thiz);

static void* pthread_func_2 (PrivInfo* thiz);

int main (int argc, char** argv)

{

pthread_t pt_1 = 0;

pthread_t pt_2 = 0;

int ret = 0;

PrivInfo* thiz = NULL;

thiz = (PrivInfo* )malloc (sizeof (PrivInfo));

if (thiz == NULL)

{

printf (“: Failed to malloc priv./n”);

return -1;

}

info_init (thiz);

ret = pthread_create (&pt_1, NULL, (void*)pthread_func_1, thiz);

if (ret != 0)

{

perror (“pthread_1_create:”);

}

ret = pthread_create (&pt_2, NULL, (void*)pthread_func_2, thiz);

if (ret != 0)

{

perror (“pthread_2_create:”);

}

pthread_join (pt_1, NULL);

pthread_join (pt_2, NULL);

info_destroy (thiz);

return 0;

}

static void info_init (PrivInfo* thiz)

{

return_if_fail (thiz != NULL);

thiz->end_time = time(NULL) + 10;

sem_init (&thiz->s1, 0, 1);

sem_init (&thiz->s2, 0, 0);

return;

}

static void info_destroy (PrivInfo* thiz)

{

return_if_fail (thiz != NULL);

sem_destroy (&thiz->s1);

sem_destroy (&thiz->s2);

free (thiz);

thiz = NULL;

return;

}

static void* pthread_func_1 (PrivInfo* thiz)

{

return_if_fail(thiz != NULL);

while (time(NULL) end_time)

{

sem_wait (&thiz->s2);

printf (“pthread1: pthread1 get the lock./n”);

sem_post (&thiz->s1);

printf (“pthread1: pthread1 unlock/n”);

sleep (1);

}

return;

}

static void* pthread_func_2 (PrivInfo* thiz)

{

return_if_fail (thiz != NULL);

while (time (NULL) end_time)

{

sem_wait (&thiz->s1);

printf (“pthread2: pthread2 get the unlock./n”);

sem_post (&thiz->s2);

printf (“pthread2: pthread2 unlock./n”);

sleep (1);

}

return;

}

版权声明：本文采用知识共享 署名4.0国际许可协议 [BY-NC-SA] 进行授权
文章名称：《「Linux」子线程不阻塞主线程：如何实现？ (linux子线程如何不阻塞主线程)》
文章链接：https://zhuji.vsping.com/29722.html
本站资源仅供个人学习交流，请于下载后24小时内删除，不允许用于商业用途，否则法律问题自行承担。
分享到

相关推荐

热门文章