Linux 多线程编程详解

简介: Linux 多线程编程详解

为什么要使用多线程

在编写代码时,是否会遇到以下的场景会感觉到难以下手?


要做 2 件事,一件需要阻塞等待,另一件需要实时进行。例如播放器:一边 在屏幕上播放视频,一边在等待用户的按键操作。如果使用单线程的话,程序必 须一会查询有无按键,一会播放视频。查询按键太久,就会导致视频播放卡顿; 视频播放太久,就无法及时响应用户的操作。并且查询按键和播放视频的代码混杂在一起,代码丑陋。


如果使用多线程,线程 1 单独处理按键,线程 2 单独处理播放,可以完美解决上述问题


线程概念

所谓线程,就是操作系统所能调度的最小单位。


普通的进程,只有一个线程在执行对应的逻辑。我们可以通过多线程编程,使一个进程可以去执行多个不同的任务。相比多进程编程而言,线程享有共享资源,即在进程中出现的全局变量, 每个线程都可以去访问它,与进程共享“4G”内存空间,使得系统资源消耗减少。 本章节来讨论 Linux 下 POSIX 线程。


线程的标识 pthread_t

对于进程而言,每一个进程都有一个唯一对应的 PID 号来表示该进程


而对于线程而言,也有一个“类似于进程的 PID 号”,名为 tid,其本质是一个 pthread_t 类型的变量。线程号与进程号是表示线程和进程的唯一标识,但是对于线程号而言,其仅仅在其所属的进程上下文中才有意义。


获取线程号


#include <pthread.h>


pthread_t pthread_self(void);


成功:返回线程号


在程序中,可以通过函数 pthread_self,来返回当前线程的线程号,例程 1 给出了打印线程 tid 号。

测试例程 1:(Phtread_txex1.c)

#include <pthread.h>
#include <stdio.h>
 
int main()
{
  pthread_t tid = pthread_self();
  printf("tid = %lu\n",(unsigned long)tid);
  return 0;
}

因采用 POSIX 线程接口,故在要编译的时候包含 pthread 库

使用 gcc 编译应 gcc xxx.c -lpthread 方可编译多线程程序

编译结果:

线程的创建

怎么创建线程呢?


使用 pthread_create 函数:


创建线程


#include <pthread.h>


int pthread_create(pthread_t *thread, const pthread_attr_t *attr,void *(*start_routine) (void *), void *arg);


  • 第一个参数为 pthread_t 指针,用来保存新建线程的线程号;
  • 第二个参数表示了线程的属性,一般传入 NULL 表示默认属性;
  • 第三个参数是一个函数指针,就是线程执行的函数。这个函数返回值为 void*, 形参为 void*。
  • 第四个参数则表示为向线程处理函数传入的参数,若不传入,可用 NULL 填充, 有关线程传参后续小节会有详细的说明,接下来通过一个简单例程来使用该函数创建出一个线程。

测试例程 2:(Phtread_txex2.c)

#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
 
void *fun(void *arg)
{
  printf("pthread_New = %lu\n",(unsigned long)pthread_self());
}
 
int main()
{
 
  pthread_t tid1;
  int ret = pthread_create(&tid1,NULL,fun,NULL);
  if(ret != 0){
    perror("pthread_create");
    return -1;
  }
 
  /*tid_main 为通过pthread_self获取的线程ID,tid_new通过执行pthread_create成功后tid指向的空间*/
  printf("tid_main = %lu tid_new = %lu \n",(unsigned long)pthread_self(),(unsigned long)tid1);
  
  /*因线程执行顺序随机,不加sleep可能导致猪线程先执行,导致进程结束,无法执行到子线程*/
  sleep(1);
 
  return 0;
}

运行结果:

通过 pthread_create 确 实 可 以 创 建 出 来 线 程 , 主 线 程 中 执 行 pthread_create 后 的 tid 指向了线程号空间,与子线程通过函数 pthread_self 打印出来的线程号一致。


特别说明的是,当主线程伴随进程结束时,所创建出来的线程也会立即结束, 不会继续执行。并且创建出来的线程的执行顺序是随机竞争的,并不能保证哪一 个线程会先运行。可以将上述代码中 sleep 函数进行注释,观察实验现象。

上述运行代码 3 次,其中有 2 次被进程结束,无法执行到子线程的逻辑,最后一 次则执行到了子线程逻辑后结束的进程。如此可以说明,线程的执行顺序不受控制,且整个进程结束后所产生的线程也随之被释放,在后续内容中将会描述如何 控制线程执行。

向线程传入参数

pthread_create()的最后一个参数的为 void*类型的数据,表示可以向线 程传递一个 void*数据类型的参数,线程的回调函数中可以获取该参数,例程 3 举例了如何向线程传入变量地址与变量值。

测试例程 3:(Phtread_txex3.c)

#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
 
void *fun1(void *arg)
{
  printf("%s:arg = %d Addr = %p\n",__FUNCTION__,*(int *)arg,arg);
}
 
void *fun2(void *arg)
{
  printf("%s:arg = %d Addr = %p\n",__FUNCTION__,(int)(long)arg,arg);
}
 
int main()
{
 
  pthread_t tid1,tid2;
  int a = 50;
  int ret = pthread_create(&tid1,NULL,fun1,(void *)&a); // 21 创建线程传入变量 a 的地址
  if(ret != 0){
    perror("pthread_create");
    return -1;
  }
  ret = pthread_create(&tid2,NULL,fun2,(void *)(long)a); // 27 创建线程传入变量 a 的值
  if(ret != 0){
    perror("pthread_create");
    return -1;
  }
  sleep(1);
  printf("%s:a = %d Add = %p \n",__FUNCTION__,a,&a);
  return 0;
}

运行结果:

例程展示了如何利用线程创建函数的第四个参数向线程传入数据,举例了如何以地址的方式传入值、以变量的方式传入值,

例程代码的 21 行,是将变量 a 先行取地址后,再次强制类型转化为 void*后传入线程,线程处理的回调函数 中,先将万能指针 void*转化为 int*,再次取地址就可以获得该地址变量的值, 其本质在于地址的传递。


例程代码的 27 行,直接将 int 类型的变量强制转化为 void*进行传递(针对不同位数机器,指针对其字数不同,需要 int 转化为 long 在转指针,否则可能会发生警告),在线程处理回调函数中,直接将 void*数据转 248 / 566 化为 int 类型即可,本质上是在传递变量 a 的值。 上述两种方法均可得到所要的值,但是要注意其本质,一个为地址传递,一 个为值的传递。当变量发生改变时候,传递地址后,该地址所对应的变量也会发 生改变,但传入变量值的时候,即使地址指针所指的变量发生变化,但传入的为 变量值,不会受到指针的指向的影响,实际项目中切记两者之间的区别。具体说明见例程 4。


测试例程 4:(Phtread_txex4.c)

#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
 
void *fun1(void *arg)
{
  while(1){
  
    printf("%s:arg = %d Addr = %p\n",__FUNCTION__,*(int *)arg,arg);
    sleep(1);
  }
}
 
void *fun2(void *arg)
{
  while(1){
  
    printf("%s:arg = %d Addr = %p\n",__FUNCTION__,(int)(long)arg,arg);
    sleep(1);
  }
}
 
int main()
{
 
  pthread_t tid1,tid2;
  int a = 50;
  int ret = pthread_create(&tid1,NULL,fun1,(void *)&a);
  if(ret != 0){
    perror("pthread_create");
    return -1;
  }
  sleep(1);
  ret = pthread_create(&tid2,NULL,fun2,(void *)(long)a);
  if(ret != 0){
    perror("pthread_create");
    return -1;
  }
  while(1){
    a++;
    sleep(1);
    printf("%s:a = %d Add = %p \n",__FUNCTION__,a,&a);
  }
  return 0;
}

运行结果:

上述例程讲述了如何向线程传递一个参数,在处理实际项目中,往往会遇到 传递多个参数的问题,我们可以通过结构体来进行传递,解决此问题。

测试例程 5:(Phtread_txex5.c)

#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
 
struct Stu{
  int Id;
  char Name[32];
  float Mark;
};
 
void *fun1(void *arg)
{
  struct Stu *tmp = (struct Stu *)arg;
  printf("%s:Id = %d Name = %s Mark = %.2f\n",__FUNCTION__,tmp->Id,tmp->Name,tmp->Mark);
  
}
 
int main()
{
 
  pthread_t tid1,tid2;
  struct Stu stu;
  stu.Id = 10000;
  strcpy(stu.Name,"ZhangSan");
  stu.Mark = 94.6;
 
  int ret = pthread_create(&tid1,NULL,fun1,(void *)&stu);
  if(ret != 0){
    perror("pthread_create");
    return -1;
  }
  printf("%s:Id = %d Name = %s Mark = %.2f\n",__FUNCTION__,stu.Id,stu.Name,stu.Mark);
  sleep(1);
  return 0;
}

运行结果:

线程的退出与回收

线程的退出情况有三种:第一种是进程结束,进程中所有的线程也会随之结束。


第二种是通过函数 pthread_exit 来主动的退出线程。


第三种被其他线程调用 pthread_cancel 来被动退出。


当线程结束后,主线程可以通过函数 pthread_join/pthread_tryjoin_np 来回收线程的资源,并且获得线程结束后需要返回的数据。


线程主动退出

pthread_exit 函数原型如下:


线程主动退出


#include <pthread.h>


void pthread_exit(void *retval);


pthread_exit 函数为线程退出函数,在退出时候可以传递一个 void*类型的数据带给主线程,若选择不传出数据,可将参数填充为 NULL。


线程被动退出

pthread_cancel 函数原型如下:


线程被动退出,其他线程使用该函数让另一个线程退出


#include <pthread.h>


int pthread_cancel(pthread_t thread);


成功:返回 0


该函数传入一个 tid 号,会强制退出该 tid 所指向的线程,若成功执行会返回 0。


线程资源回收(阻塞方式)

thread_join 函数原型如下:


线程资源回收(阻塞)


#include <pthread.h>


int pthread_join(pthread_t thread, void **retval);


该函数为线程回收函数,默认状态为阻塞状态,直到成功回收线程后才返回。第一个参数为要回收线程的 tid 号,第二个参数为线程回收后接受线程传出的数据。


线程资源回收(非阻塞方式)

pthread_tryjoin_np 函数原型如下:


线程资源回收(非阻塞)


#define _GNU_SOURCE


#include <pthread.h>


int pthread_tryjoin_np(pthread_t thread, void **retval);


该函数为非阻塞模式回收函数,通过返回值判断是否回收掉线程,成功回 收则返回 0,其余参数与 pthread_join 一致。


测试例程 6:(Phtread_txex6.c)

#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
 
void *fun1(void *arg)
{
  static int tmp = 0; // 8 必须要static修饰,否则pthread_join无法获取到正确值
  //int tmp = 0;
  tmp = *(int *)arg;
  tmp+=100;
  printf("%s:Addr = %p tmp = %d\n",__FUNCTION__,&tmp,tmp);
  pthread_exit((void *)&tmp);
}
 
 
int main()
{
 
  pthread_t tid1;
  int a = 50;
  void *Tmp = NULL;
  int ret = pthread_create(&tid1,NULL,fun1,(void *)&a); // 23
  if(ret != 0){
    perror("pthread_create");
    return -1;
  }
  pthread_join(tid1,&Tmp);
  printf("%s:Addr = %p Val = %d\n",__FUNCTION__,Tmp,*(int *)Tmp);
  return 0;
}

运行结果:

上述例程先通过 23 行将变量以地址的形式传入线程,在线程中做出了自加 100 的操作,当线程退出的时候通过线程传参,用 void*类型的数据通过 pthread_join 接 受 。 此 例 程 去 掉 了 之 前 加 入 的 sleep 函 数 , 原 因 是 pthread_join 函数具备阻塞的特性,直至成功收回掉线程后才会冲破阻塞,因 此不需要靠考虑主线程会执行到 30 行结束进程的情况。


特别要说明的是例程第 8 行,当变量从线程传出的时候,需要加 static 修饰,对生命周期做出延续, 否则无法传出正确的变量值。


测试例程 7:(Phtread_txex7.c)

#define _GNU_SOURCE 
#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
 
void *fun(void *arg)
{
  printf("Pthread:%d Come !\n",(int )(long)arg+1);
  pthread_exit(arg);
}
 
 
int main()
{
  int ret,i,flag = 0;
  void *Tmp = NULL;
  pthread_t tid[3];
  for(i = 0;i < 3;i++){
    ret = pthread_create(&tid[i],NULL,fun,(void *)(long)i);
    if(ret != 0){
      perror("pthread_create");
      return -1;
    }
  }
  while(1){
    for(i = 0;i <3;i++){
      if(pthread_tryjoin_np(tid[i],&Tmp) == 0){
        printf("Pthread : %d exit !\n",(int )(long )Tmp+1);
        flag++; 
      }
    }
    if(flag >= 3) break;
  }
  return 0;
}

运行结果:

例程 7 展示了如何使用非阻塞方式来回收线程,此外也展示了多个线程可 以指向同一个回调函数的情况。

例程 6 通过阻塞方式回收线程几乎规定了线程回收的顺序,若最先回收的线程未退出,则一直会被阻塞,导致后续先退出的 线程无法及时的回收。


通过函数 pthread_tryjoin_np,使用非阻塞回收,线程可以根据退出先 后顺序自由的进行资源的回收。


测试例程 8:(Phtread_txex8.c)

#define _GNU_SOURCE 
#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
 
void *fun1(void *arg)
{
  printf("Pthread:1 come!\n");
  while(1){
    sleep(1);
  }
}
 
void *fun2(void *arg)
{
  printf("Pthread:2 come!\n");
  pthread_cancel((pthread_t )(long)arg); // 杀死线程 1,使之强制退出
  pthread_exit(NULL);
}
 
int main()
{
  int ret,i,flag = 0;
  void *Tmp = NULL;
  pthread_t tid[2];
  ret = pthread_create(&tid[0],NULL,fun1,NULL); // 27
  if(ret != 0){
    perror("pthread_create");
    return -1;
  }
  sleep(1);
  ret = pthread_create(&tid[1],NULL,fun2,(void *)tid[0]); // 33 传输线程 1 的线程号
 
  if(ret != 0){
    perror("pthread_create");
    return -1;
  }
  while(1){ //通过非阻塞方式收回线程,每次成功回收一个线程变量自增,直至 2 个线程全数回收
    for(i = 0;i <2;i++){
      if(pthread_tryjoin_np(tid[i],NULL) == 0){
        printf("Pthread : %d exit !\n",i+1);
        flag++; 
      }
    }
    if(flag >= 2) break;
  }
  return 0;
}

运行结果:

例程 8 展示了如何利用 pthread_cancel 函数主动的将某个线程结束。

27 行与 33 行创建了线程,将第一个线程的线程号传参形式传入了第二个线程。第一个的线程执行死循环睡眠逻辑,理论上除非进程结束,其永远不会结束,但在第二个线程中调用了 pthread_cancel 函数,相当于向该线程发送一个退出的指令,导致线程被退出,最终资源被非阻塞回收掉。


此例程要注意第 32 行的 sleep 函数,一定要确保线程 1 先执行,因线程是无序执行,故加入该睡眠函数控制顺序

相关文章
|
13天前
|
消息中间件 存储 缓存
【嵌入式软件工程师面经】Linux系统编程(线程进程)
【嵌入式软件工程师面经】Linux系统编程(线程进程)
24 1
|
1天前
|
Java
【编程侦探社】追踪 Java 线程:一场关于生命周期的侦探故事!
【6月更文挑战第19天】在Java世界中,线程如同神秘角色,编程侦探揭示其生命周期:从新生(`new Thread()`)到就绪(`start()`),面临并发挑战如资源共享冲突。通过`synchronized`实现同步,处理阻塞状态(如等待锁`synchronized (lock) {...}`),最终至死亡,侦探深入理解并解决了多线程谜题,成为编程侦探社的传奇案例。
|
2天前
|
Java 程序员
Java多线程编程是指在一个进程中创建并运行多个线程,每个线程执行不同的任务,并行地工作,以达到提高效率的目的
【6月更文挑战第18天】Java多线程提升效率,通过synchronized关键字、Lock接口和原子变量实现同步互斥。synchronized控制共享资源访问,基于对象内置锁。Lock接口提供更灵活的锁管理,需手动解锁。原子变量类(如AtomicInteger)支持无锁的原子操作,减少性能影响。
16 3
|
3天前
|
数据采集 安全 算法
Java并发编程中的线程安全与性能优化
在Java编程中,多线程并发是提升程序性能的关键之一。本文将深入探讨Java中的线程安全性问题及其解决方案,并介绍如何通过性能优化技术提升多线程程序的效率。
9 3
|
3天前
|
API
Linux---线程读写锁详解及代码实现
Linux---线程读写锁详解及代码实现
|
3天前
|
API
linux---线程互斥锁总结及代码实现
linux---线程互斥锁总结及代码实现
|
3天前
|
Linux API
Linux线程总结---线程的创建、退出、取消、回收、分离属性
Linux线程总结---线程的创建、退出、取消、回收、分离属性
|
6天前
|
存储 安全 Java
Java多线程编程--JUC
Java多线程编程
|
9天前
|
算法 Linux 测试技术
Linux编程:测试-高效内存复制与随机数生成的性能
该文探讨了软件工程中的性能优化,重点关注内存复制和随机数生成。文章通过测试指出,`g_memmove`在内存复制中表现出显著优势,比简单for循环快约32倍。在随机数生成方面,`GRand`库在1000万次循环中的效率超过传统`rand()`。文中提供了测试代码和Makefile,建议在性能关键场景中使用`memcpy`、`g_memmove`以及高效的随机数生成库。
|
12天前
|
安全 开发者 Python
Python中的多线程与多进程编程
Python作为一种广泛使用的编程语言,在处理并发性能时具有独特的优势。本文将深入探讨Python中的多线程与多进程编程技术,分析其原理和应用,帮助读者更好地理解并发编程在Python中的实现与优化。

热门文章

最新文章