Linux 中线程的实现

最新推荐文章于 2024-02-29 19:40:09 发布
最新推荐文章于 2024-02-29 19:40:09 发布
阅读量1.1k 收藏 5
点赞数 7
分类专栏： Linux 文章标签： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_47358666/article/details/116882870
版权

文章目录

一、线程的概念

线程：进程内部的一条执行路径或序列，一个进程可以包含多条线程。（CPU调度和执行的基本单位）
例如:main()函数从第一行开始运行直到主函数结束
进程：一个正在进行的程序 （资源分配的基本单位）

在这里插入图片描述

二、线程的实现方式

在操作系统中，线程的实现有以下三种方式：
◼ 内核级线程
◼ 用户级线程
◼ 组合级线程

在这里插入图片描述

用户级与内核级的区别：
用户级：创建开销小，由线程库直接管理。无法使用多处理器资源
内核级：创建开销大，由内核直接管理。可以使用多处理器的资源

Linux实现线程的机制非常独特。从内核的角度来说，它并没有线程这个概念。Linux把所有的线程都当作进程来实现。内核并没有准备特别的调度算法或是定义特别的数据结构来表征线程。相反，线程仅仅被视为一个与其他进程共享某些资源的进程。每个线程都拥有唯一隶属于自己的task_struct，所以在内核中，它看起来就就像是一个普通的进程（只是该进程和其他一些进程共享某些资源，如地址空间）。

ps -eLf 可以看到进程中的线程
在这里插入图片描述

三、线程库中的接口介绍

#include <pthread.h>//头文件

int pthread_create(pthread_t *thread, const pthread_attr_t*attr,void *(*start_routine) (void *), void *arg);
/*
pthread_create()用于创建线程
thread： 接收创建的线程的 ID
attr： 指定线程的属性
start_routine： 指定线程函数
arg： 给线程函数传递的参数
成功返回 0， 失败返回错误码
*/


int pthread_exit(void *retval);
 /*
pthread_exit()退出线程
retval：指定退出信息
*/


int pthread_join(pthread_t thread, void **retval);
 /*
pthread_join()等待 thread 指定的线程退出，线程未退出时，该方法阻塞
retval：接收 thread 线程退出时，指定的退出信息
*/

四、线程的简单使用

4.1.主函数创建一个线程

   #include<stdio.h>
   #include<string.h>
   #include<assert.h>
   #include<unistd.h>
   #include<stdlib.h>
   #include<pthread.h>
   
   void* fun(void*arg)
   {
  
      int i = 0;
      for(;i < 10;i++)
      {
          printf("fun hello\n");
          sleep(1);
      }
   
     
  }
  
  int main()
  {   
      pthread_t id;
      pthread_create(&id,NULL,fun,NULL);
      
      int i = 0;
      for(;i < 5;i++)
      {
          printf("main hello\n");
          sleep(1);
      }
   }

问题：main()跟fun()并发进行，但是main()结束时，fun()并没有完成自己的工作，也跟着main()结束。

解决办法：使用pthread_exit()以及pthread_join()让主线程main等待fun结束之后再结束。

   #include<stdio.h>
   #include<string.h>
   #include<assert.h>
   #include<unistd.h>
   #include<stdlib.h>
   #include<pthread.h>
   
   void* fun(void*arg)
   {
  
      int i = 0;
      for(;i <10;i++)
      {
          printf("fun hello\n");
          sleep(1);
      }
   
      pthread_exit("fun over");
  }
  
  int main()
  {   
      pthread_t id;
      pthread_create(&id,NULL,fun,NULL);
      
      int i = 0;
      for(;i < 5;i++)
      {
          printf("main hello\n");
          sleep(1);
      }
   
      char *s = NULL;
      pthread_join(id,(void**)&s);
      printf("s = %s\n",s);
  }

4.2.主函数创建多个线程

   #include<stdio.h>
   #include<string.h>
   #include<assert.h>
   #include<unistd.h>
   #include<stdlib.h>
   #include<pthread.h>
   
   
   void* thread(void * arg)
  {
      int index = *(int *)arg;
      int i = 0;
      for(;i<3;i++)
      {
          printf("index = %d\n",index);
          sleep(1);
      }
  }
  int main()
  {
      pthread_t id[5];
      int i = 0;
      for(;i<5;i++)
      {
          pthread_create(&id[i],NULL,thread,(void*)&i);
      }
  
      for(i = 0;i<5;i++)
      {
          pthread_join(id[i],NULL);
      }
  
      exit(0);
  
  }

通过运行代码，发现运行的结果不是像我们预料的那样，每隔1秒，输出0-4（顺序可能会乱）。
实际的输出结果并不是这样的，原因是pthread_creat参数传入的是i的地址，而i的值在变化，当进程要获取i的值的时候，可能已经不是当初传进来的那个值，所以就会出现这种情况。
解决：传入i的值而不是地址

   #include<stdio.h>
   #include<string.h>
   #include<assert.h>
   #include<unistd.h>
   #include<stdlib.h>
   #include<pthread.h>
   
   
   void* thread(void * arg)
  {
      int index = (int)arg;
      int i = 0;
      for(;i<3;i++)
      {
          printf("index = %d\n",index);
          sleep(1);
      }
  }
  int main()
  {
      pthread_t id[5];
      int i = 0;
      for(;i<5;i++)
      {
          pthread_create(&id[i],NULL,thread,(void*)i);
      }
  
      for(i = 0;i<5;i++)
      {
          pthread_join(id[i],NULL);
      }
  
      exit(0);
  
  }

4.3.多进程对一个变量进行操作

   #include<stdio.h>
   #include<string.h>
   #include<assert.h>
   #include<unistd.h>
   #include<stdlib.h>
   #include<pthread.h>
   
   int g = 0;
   void* thread(void * arg)
  {
      int i = 0;
      for(;i<1000;i++)
      {
          printf("g = %d\n",++g);
      }
  }
  int main()
  {
      pthread_t id[5];
      int i = 0;
      for(;i<5;i++)
      {
          pthread_create(&id[i],NULL,thread,NULL);
      }
  
      for(i = 0;i<5;i++)
      {
          pthread_join(id[i],NULL);
      }
  
      exit(0);
  
  }

多次运行之后，发现某一次g没有加到5000，原因是再某一时刻，两个线程或多个线程同时对g进行+1操作，而最终两个线程或多个线程只是对g进行了一次+1操作，导致g没有加到5000

解决：使用互斥锁，信号量等

   #include<stdio.h>
   #include<string.h>
   #include<assert.h>
   #include<unistd.h>
   #include<stdlib.h>
   #include<pthread.h>
   
   int g = 0;
  
  pthread_mutex_t mutex;
  void* thread(void * arg)
  {
      int i = 0;
      for(;i<1000;i++)
      {
          pthread_mutex_lock(&mutex);
          printf("g = %d\n",++g);
          pthread_mutex_unlock(&mutex);
      }
  }
  int main()
  {
      pthread_mutex_init(&mutex,NULL);
      pthread_t id[5];
      int i = 0;
      for(;i<5;i++)
      {
          pthread_create(&id[i],NULL,thread,NULL);
      }
  
      for(i = 0;i<5;i++)
      {
          pthread_join(id[i],NULL);
      }
      pthread_mutex_destroy(&mutex);
      exit(0);
  
  }
~

五、线程安全

线程安全：简单来说线程安全就是多个线程并发同一段代码时（不管线程的运行顺序如何），都会出现想要的结果，我们就可以说该线程是安全的。

strtok()函数不能在多线程中使用
例如下面的函数：

   #include<stdio.h>
   #include<stdlib.h>
   #include<assert.h>
   #include<unistd.h>
   #include<string.h>
   #include<pthread.h>
   
   void* fun(void * arg)
   {
      char buff[] = {"1 2 3 4 5 6 7 8 9"};
      char *s = strtok(buff," ");
      while( s != NULL )
      {
          printf("fun s = %s\n",s);
          sleep(1);
          s = strtok(NULL," ");
      }
  }
  
  int main()
  {
      pthread_t id;
      pthread_create(&id,NULL,fun,NULL);
  
      char str[] = {"a b c d e f g k l"};
     
      char *p = strtok(str," ");
      while( p !=  NULL)
      {
          printf("p = %s\n",p);
          sleep(1);
          p = strtok(NULL," ");
      }
  
      pthread_join(id,NULL);
  }

改进方法：使用strtok_r()函数：

   #include<stdio.h>
   #include<stdlib.h>
   #include<assert.h>
   #include<unistd.h>
   #include<string.h>
   #include<pthread.h>
   
   void* fun(void * arg)
   {
      char buff[] = {"1 2 3 4 5 6 7 8 9"};
      char * ptr = NULL;
      char *s = strtok_r(buff," ",&ptr);
      while( s != NULL )
      {
          printf("fun s = %s\n",s);
          sleep(1);
          s = strtok_r(NULL," ",&ptr);
      }
  }
  
  int main()
  {
      pthread_t id;
      pthread_create(&id,NULL,fun,NULL);
  
      char str[] = {"a b c d e f g k l"};
      char *ptr  = NULL;
      char *p = strtok_r(str," ",&ptr);
      while( p !=  NULL)
      {
          printf("p = %s\n",p);
          sleep(1);
          p = strtok_r(NULL," ",&ptr);
      }
  
      pthread_join(id,NULL);
  }

六、线程创建

6.1.创建进程上限

   #include<stdio.h>
   #include<stdlib.h>
   #include<assert.h>
   #include<unistd.h>
   #include<string.h>
   #include<pthread.h>
   
   void* fun(void * arg)
   {
      while(1)
      {
          sleep(1);
      }
  }
  
  int main()
  {
      pthread_t id;
      int i = 0;
      for(l;i<10000;i++)
      {
          int res = pthread_create(&id,NULL,fun,NULL);
          if(res != 0)
          {
              break;
          }
          printf("i = %d\n",i);
      }
  
      pthread_join(id,NULL);
  }

6.2.线程+fork()

   #include<stdio.h>
   #include<stdlib.h>
   #include<assert.h>
   #include<unistd.h>
   #include<string.h>
   #include<pthread.h>
   
   void *fun(void* arg)
   {
      fork();
  
      int i = 0;
      for(;i<5;i++)
      {
          printf("fun run pid = %d\n",getpid());
          sleep(1);
      }
  }
  int main()
  {
      pthread_t id;
      pthread_create(&id,NULL,fun,NULL);
  
      int i = 0;
      for(;i<5;i++)
      {
          printf("main run pid = %d\n",getpid());
          sleep(1);
      }
  }

6.3.线程+互斥锁+fork

   #include<stdio.h>
   #include<stdlib.h>
   #include<assert.h>
   #include<unistd.h>
   #include<string.h>
   #include<pthread.h>
   #include<sys/wait.h>
   pthread_mutex_t mutex;
   
  void *fun(void* arg)
  {
  
      pthread_mutex_lock(&mutex);
      printf("fun lock!\n");
      sleep(5);
      pthread_mutex_unlock(&mutex);
      printf("fun unlock\n");
  }
  int main()
  {
      pthread_t id;
      pthread_mutex_init(&mutex,NULL);
      pthread_create(&id,NULL,fun,NULL);
      sleep(1);
  
      pid_t pid = fork();
      assert(pid != -1);
  
      if(pid == 0)
      {
          printf("child lock start\n");
          pthread_mutex_lock(&mutex);
          printf("child lock success!\n");
          pthread_mutex_unlock(&mutex);
          exit(0);
      }
      wait(NULL);
      printf("main over\n");
  }

fork()会复制父进程的锁，初始状态由复制时父进程中锁的状态决定。所以该程序会阻塞
解决办法：使用pthread_atfork()对fork进行限制，fork之前加锁，之后解锁。

   #include<stdio.h>
   #include<stdlib.h>
   #include<assert.h>
   #include<unistd.h>
   #include<string.h>
   #include<pthread.h>
   #include<sys/wait.h>
   pthread_mutex_t mutex;
   
  void fun_lock()
  {
      pthread_mutex_lock(&mutex);
  
  }
  
  void fun_unlock()
  {    
      pthread_mutex_unlock(&mutex);
  }
  void *fun(void* arg)
  {   
      
      pthread_mutex_lock(&mutex);
      printf("fun lock!\n");
      sleep(5);
      pthread_mutex_unlock(&mutex);
      printf("fun unlock\n");
  }
  int main()
  {   
      pthread_atfork(fun_lock,fun_unlock,fun_unlock);
      pthread_t id;
      pthread_mutex_init(&mutex,NULL);
      pthread_create(&id,NULL,fun,NULL);
      sleep(1);
      
      pid_t pid = fork();
      assert(pid != -1);
      
      if(pid == 0)
      {
          printf("child lock start\n");
          pthread_mutex_lock(&mutex);
          printf("child lock success!\n");
          pthread_mutex_unlock(&mutex);
          exit(0);
      }
      wait(NULL);
      printf("main over\n");
  }

6.4.三个线程依次输出ABC（线程+信号量）

题目说明：三个线程，第一个线程输出A，第二个线程输出B，第三个线程输出C（要求：第一个要输出A，A输出完成之后才能输出B，B输出完成之后才能输出C。例如：ABCABCABC）

   #include<stdio.h>
   #include<stdlib.h>
   #include<assert.h>
   #include<unistd.h>
   #include<string.h>
   #include<pthread.h>
   #include<semaphore.h>
   
   sem_t sem1;
   sem_t sem2;
   sem_t sem3;
  
  
  void* fun1(void* arg)
  {
      int i = 0;
      for(;i<5;i++)
      {
          sem_wait(&sem1);//ps1
          printf("A");
          fflush(stdout);
          sem_post(&sem2);//vs2
      }
  }
  
  void* fun2(void* arg)
  {
      int i = 0;
      for(;i<5;i++)
      {
          sem_wait(&sem2);//ps2
          printf("B");
          fflush(stdout);
          sem_post(&sem3);//vs3
      }
  }
  void* fun3(void* arg)
  {
      int i = 0;
      for(;i<5;i++)
      {
          sem_wait(&sem3);//ps3
          printf("C");
          fflush(stdout);
          sem_post(&sem1);//vs1
      }
  }
  int main()
  {
      sem_init(&sem1,0,1);
      sem_init(&sem2,0,0);
      sem_init(&sem3,0,0);
  
      pthread_t id[3];
      pthread_create(&id[0],NULL,fun1,NULL);
      pthread_create(&id[1],NULL,fun2,NULL);
      pthread_create(&id[2],NULL,fun3,NULL);
  
      int i = 0;
      for(;i<3;i++)
      {
          pthread_join(id[i],NULL);
      }
  
      sem_destroy(&sem1);
      sem_destroy(&sem2);
      sem_destroy(&sem3); 
  }

输出结果：ABCABCABCABCABC

__小柒
关注
  • 7
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
Linux中的线程
01-27
线程是程序执行时的最小单位，即CPU调度和分派的基本单位，一个进程可以由多个线程组成，同一个进程中的多个线程之间共享此进程的所有资源，每个线程有自己的堆栈和局部变量。线程由CPU独立调度执行，在多CPU环境下...
Linux多进程/线程编程之【fork()和exec()】
weixin_53351963的博客
03-17 2196
在多进程中fork()和exec()通常是结合起来一起使用,在多线程中，通常不建议使用fork()和exec()
线程（Linux系统实现）
好好学习，天天向上
06-03 1120
本文讲述了什么是线程，以及在Linux系统下线程的相关操作
深入理解Linux线程（LWP）：概念、结构与实现机制（1）
最新发布
B1ue还在专注
02-29 1744
Linux线程（LWP）知识点总结（1）(ᕑᗢᓫ∗)˒
线程（Linux应用编程篇）
栋哥修炼日记
04-17 626
与线程相关的就是并发 一、线程初识 线程是参与系统调度的最小单位。它被包含在进程之中，是进程中的实际运行单位。一个线程指的是进程中一个单一顺序的控制流（或者说是执行路线、执行流），一个进程中可以创建多个线程，多个线程实现并发运行，每个线程执行不同的任务。 当一个程序启动时，就有一个进程被操作系统（OS）创建，与此同时一个线程也立刻运行，该线程通常叫做程序的主线程（Main Thread），因为它是程序一开始时就运行的线程。应用程序都是以 main()做为入口开始运行的，所以main()函数就是主线程
Linux系统线程创建的过程
KingOfMyHeart的博客
06-26 1320
Linux系统线程创建的流程
在LINUX下利用pthread库进行多线程编程 ---
happylzs2008的专栏
11-24 1010
https://blog.csdn.net/chenlin060607/article/details/8184118 1、概述 多线程程序作为一种多任务、并发的工作方式，有以下的优点： 　　1)提高应用程序响应。这对图形界面的程序尤其有意义，当一个操作耗时很长时，整个系统都会等待这个操作，此时程序不会响应键盘、鼠标、菜单的操作，而使用多线程技术，将耗时长的操作（timeconsumin...
linux中c语言实现多线程ping命令
02-08
c语言实现linux下多线程ping命令，可以ping一个网段，格式为./XX 14.215.177.38 14.215.177.40（以百度ip地址为例）
Linux 多线程实现生产者消费者模式.pdf
08-20
Linux 多线程实现生产者消费者模式.pdf
linux线程实现定时器源码
02-24
linux线程实现定时器源码
Linux线程详解
热门推荐
小虾米编程
06-03 3万+
并行和并发的区别 1. 并发(concurrency)：在操作系统中，是指一个时间段中有几个程序都处于已启动运行到运行完毕之间，且这几个程序都是在同一个处理机上运行。其中两种并发关系分别是同步和互斥。（并发是指同一时刻只能有一条指令执行，但多个进程指令被快速轮换执行，使得在宏观上有多个进程被同时执行的效果--宏观上并行，针对单核处理器） 互斥：进程间相互排斥的使用临界资源的现象，就叫互斥。 ...
Linux 线程浅析
04-19
Linux 线程浅析
Linux多线程概念及实现
向未来❀去探索 的博客
07-01 1904
Linux多线程概念及实现
Linux多线程
m0_56821563的博客
04-15 840
本篇博客主要讲述了线程概念和线程控制两方面内容。
Linux之线程
hello
02-25 1807
和多进程相比，多线程是一种比较节省资源的多任务操作方式。启动一个新的进程必须分配给它独立的地址空间，每个进程都有自己的堆栈段和数据段，系统开销比较高，进行数据的传递只能通过进行间通信的方式进行。在同一个进程中，可以运行多个线程，运行于同一个进程中的多个线程，它们彼此之间使用相同的地址空间，共享全局变量和对象，启动一个线程所消耗的资源比启动一个进程所消耗的资源要少。.........
linux c语言 创建线程任务
m0_57046226的博客
01-02 459
创建任务
linux三个线程输出abc,三个线程循环输出ABC10次
weixin_30184337的博客
05-10 183
import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;public class ABC {private static int state=0;/*** @param args*/public static void main(String[] args) {final Lock...
Linux系统编程：多线程交替打印ABC
NiGo的博客
07-21 2753
引言 分享关于线程的一道测试题，因为网上基本都是Java的解决方法，决定自己写一篇来记录一下线程的学习。 问题描述 编写一个至少具有三个线程的程序(称之为线程 A、B 和 C),其中线程 A 输出字符’A’，线程 B 输出字符’B’,线程 C 输出字符’C’。使得最终输出结果为“ABCABCABC…”。 思路 拿到这题后，我的想法是把问题简化。 原题让我们交替打印ABC，那么我们只要先考虑如何交替打印AB即可，然后在B之后衔接C，在C之后衔接A即可。 那么，如何使两个线程能够按照顺序去执行任务呢？ 关于线程
Linux网络接口操作之if_nameindex
weixin_34383618的博客
05-13 1722
系统信息 操作系统： # lsb_release -ir Distributor ID: CentOS Release: 6.7 内核版本： # uname -r 2.6.32-573.26.1.el6.x86_64 gcc版本： # gcc --version gcc (GCC) 4.4.7 20120313 ...
linux线程栅栏如何实现
05-26
在 Linux 中，线程栅栏可以使用 pthread 库中的 pthread_barrier_t 类型和相关函数来实现。具体的实现过程如下： 1. 定义一个 pthread_barrier_t 类型的变量和一个整型变量，用于指定需要等待的线程数目。 ``` pthread_barrier_t my_barrier; int num_threads = 4; ``` 2. 初始化 barrier 变量，并指定需要等待的线程数目。 ``` pthread_barrier_init(&my_barrier, NULL, num_threads); ``` 3. 在需要等待的线程中，调用 pthread_barrier_wait 函数来等待其他线程。 ``` // 线程1 pthread_barrier_wait(&my_barrier); // 线程2 pthread_barrier_wait(&my_barrier); // 线程3 pthread_barrier_wait(&my_barrier); // 线程4 pthread_barrier_wait(&my_barrier); ``` 4. 当所有线程都到达 barrier 时，所有线程将会被唤醒，并可以继续执行后面的代码。 需要注意的是，当所有线程都到达 barrier 后，它们会被唤醒并继续执行。因此，在使用线程栅栏时，需要保证每个线程都能够到达 barrier 处，否则可能会导致死锁或者其他错误。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

__小柒

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值