Linux:线程控制

最新推荐文章于 2024-06-08 20:42:25 发布
最新推荐文章于 2024-06-08 20:42:25 发布
阅读量340 收藏 1
点赞数 5
分类专栏： Linux 文章标签： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43825377/article/details/114552971
版权

Linux:线程控制

线程的创建

前面我们已经基本了解了线程的基本概念,接下来我们面临的问题就是是怎让创建一个线程了,在Linux中可以用pthread_create函数来创建线程.

函数原型:
#include <pthread.h>

       int pthread_create(pthread_t *thread, const pthread_attr_t *attr,void *(*start_routine) (void *), void *arg);
参数解释:
	thread:返回线程ID
	attr:设置线程的属性,为NULL表示使用默认属性
	start_routine:是一个函数地址,线程启动后要执行的函数
	arg:传给线程启动的参数
返回值:
	成功返回0;失败返回错误码

可以看到这个函数在3号手册,证明这个函数是一个库函数,这也就证明了线程不是操作系统为我们提供的
在这里插入图片描述
例子:

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

void* TStart(void* arg)
{
    while(1)
    {
        printf("I am work thread!\n");
        sleep(1);
    }
    return NULL;
}

int main()
{
    pthread_t tid;
    int ret = pthread_create(&tid, NULL, TStart, NULL);
    if(ret < 0)
    {
        perror("pthread_create");
        return -1;
    }

    while(1)
    {
        printf("I am main thread!\n");
        sleep(1);
    }
    return 0;
}

运行结果:
在这里插入图片描述
注意:编译多线程程序的时候一定要加上-lpthread选项
接下来我们通过两个代码来验证一下在创建多线程的时候应该传递什么样的参数：
代码1：

 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <pthread.h>
 
 void *myThread(void* arg)
 {
   int* p = (int*)arg;
   while(1)
   {
     printf("I am work thread:%p, i = %d\n",pthread_self(),*p);
     sleep(1);
   }
   return NULL;
 }
 int main()
 {
   pthread_t tid;
   for(int i = 0;i < 4;++i)
   {
      int ret = pthread_create(&tid,NULL ,myThread, &i);
      if(ret < 0)
      {
        perror("pthread_create");
        return -1;
      }
   }
   while(1)                                                                                   
   {
     printf("I am main thread\n");
     sleep(1);
   }
   return 0;
 }

运行结果：
在这里插入图片描述
在上面的代码中，我们创建出了四个线程，发现打印的时候漏掉了0和1，而且后面一直打印的i都等于4，产生这样结果的原因是：i的作用域仅在循环内，出了for循环就被释放了，其次最后i的内容为4，即传给每个线程的值都变成4，且由于i是在栈上开辟的，出了作用域后在栈上开辟的空间也被释放了，但是线程依然在访问i，也就造成了越界，程序崩溃（没有崩溃的原因是这段空间还没有被其它的程序使用到)。
代码2：

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

  struct Data                                                           
  {                                                                     
    int data_;                                                               
  };                                                                         
  void* myPthread(void* arg)                                                 
  {                                                                                                                                 
    Data* d = (Data*)arg;                                           
    while(1)                                                        
      {                              
      printf("i am workthread %p, i = %d\n", pthread_self(), d->data_);    
        sleep(1);                    
                                                                    
      }                                                             
      delete d;                                                     
      d = NULL;                                                     
      return NULL;
  }
  int main()
  {
    pthread_t tid;
    for(int i = 0;i < 4;i++)
    {
      Data* d = new Data();
      d->data_ = i;
      int ret = pthread_create(&tid, NULL, myPthread, (void*)d);
      if(ret < 0)
      {
        perror("pthread_create");
        return -1;
      }
    }
      while(1)
      {
        printf("I am mainpthread!\n");
        sleep(1);
      }                                                                                          
    return 0;
  }

运行结果：
在这里插入图片描述
对比代码1和代码2，显然代码1的结果是和实际不符的，仔细对比代码我们发现代码1中的i是临时变量，是在栈中存储的，而代码2中的d是在堆中存储的，所以我们得出的结论是：创建线程时传递的参数的是在堆中开辟的变量才可以

线程的终止

线程的终止和进程的终止一样，也是有三种方法：
（1）从入口函数的return饭hi，该线程就退出掉了
代码：

  #include <stdio.h>    
  #include <pthread.h>    
  #include <unistd.h>    
      
  void* myPthread(void* arg)    
  {    
    while(1)    
    {    
      printf("I am workThread!\n");    
      sleep(3);    
      return NULL;                                                                              
    }    
    return NULL;    
  }    
  int main()    
  {    
    pthread_t tid;    
    int ret = pthread_create(&tid,NULL,myPthread,NULL);    
    if(ret < 0)    
    {    
      perror("pthread_create");    
      return -1;    
    }    
    while(1)    
    {    
      printf("I am mainthread!\n");    
      sleep(1);    
    }    
    return 0;    
  }

（2）pthread_exit函数

函数原型：
#include <pthread.h>

void pthread_exit(void *retval);
参数解释：
	retval:返回信息，可以给也可以不给，是返回给等待线程退出的执行流的，如果不给，则传递NULL

代码：
在这里插入图片描述

  #include <stdio.h>    
  #include <stdlib.h>    
  #include <unistd.h>    
  #include <pthread.h>    
      
  void* myPthread(void* arg)    
  {    
    sleep(5);                                                                                    
    printf("I am workthread!\n");    
    pthread_exit(NULL);    
    return NULL;    
  }    
  int main()    
  {    
    pthread_t tid;    
    int ret = pthread_create(&tid,NULL,myPthread,NULL);    
    if(ret < 0)    
    {    
      perror("pthread_create");    
      return -1;    
    }    
    while(1)    
    {    
      printf("I am manThread!\n");    
      sleep(1);    
    }    
    return 0;    
  }

运行结果：
在这里插入图片描述

（3）pthread_cancel函数

函数原型：
 #include <pthread.h>

 int pthread_cancel(pthread_t thread);
 参数解释：
 	thread:线程标识符
返回值：
	成功，返回0；错误返回错误码

注意：调用该函数的执行流可以取消其它线程，但是需要知道其他线程的线程标识符，也可以执行自己的取消自己，传入自己的线程标识符
获取自己的线程标识符的方法：pthread_self();

  #include <stdio.h>    
  #include <pthread.h>    
  #include <unistd.h>    
      
  void* myPthread(void* arg)    
  {    
    while(1)    
    {    
      printf("I am workThread!\n");    
      sleep(3);                                                                                  
      pthread_cancel(pthread_self());    
    }    
    return NULL;    
  }    
  int main()    
  {    
    pthread_t tid;    
    int ret = pthread_create(&tid,NULL,myPthread,NULL);    
    if(ret < 0)    
    {    
      perror("pthread_create");    
      return -1;    
    }    
    while(1)    
    {    
      printf("I am mainthread!\n");    
      sleep(1);    
    }    
    return 0;    
  }

运行结果：
在这里插入图片描述
上面的代码运行结果都出现在打印“I am workThread!”以后就一直打印”I am mainThread!“的情况，因为此时我们创建的线程已经被退出了，只剩下主线程了。我们也可以使用pstack [进程号]命令查看。
把上面程序里的睡眠时间从3秒改到20秒，然后用ps命令产看线程标识符
在这里插入图片描述
用pstack [进程号命令查看]
在这里插入图片描述
这里我们就看到了我们创建的进程，过了20秒后我们在看一下
在这里插入图片描述
这次我们就只看到主线程了，因为我们创建的工作线程已经被我们退出掉了。

线程等待

如果上面的主线程先于我们创建的线程退出了会出现什么情况呢？我们写一个程序来看一下，在这个程序中我们让主线程退出掉。
代码：

  #include <stdio.h>    
  #include <stdlib.h>    
  #include <pthread.h>    
  #include <unistd.h>    
      
  void* myPthread(void* arg)    
  {    
    while(1)    
    {    
      printf("I am workThread!\n");    
      sleep(1);                                                                                  
    }    
  }    
  int main()    
  {    
    pthread_t tid;    
    int ret = pthread_create(&tid,NULL,myPthread,NULL);    
    if(ret < 0)    
    {    
      perror("pthread_create");    
      return -1;    
    }    
    while(1)    
    {    
      printf("I am mainThread!\n");    
      pthread_cancel(pthread_self());    
      sleep(1);    
    }    
    return 0;    
  }

运行结果：
在这里插入图片描述
我们看到主线程退出以后，工作线程还在继续工作，我们用ps命令查看一下它的状态，结果显示它正在处于僵尸状态
在这里插入图片描述
再用top -H -p [进程号]查看一下
在这里插入图片描述
因为已经退出的线程，他的空间没有被释放，还在进程的地址空间内，而新创建的线程是不会复用刚退出的地址空间的（线程在创建出来的时候属性默认的是joinable属性，这就意味着线程退出的时候需要其它执行流来回收线程的资源），这就需要线程等待了。
线程等待我们需要用到的函数是pthread_join函数。

函数原型：
 #include <pthread.h>

 int pthread_join(pthread_t thread, void**retval);
参数说明：
	thread：要等待的线程的标识符
	**retval：
		return：接受入口函数的返回值
		pthread_exit:接收pthread_exit函数的参数
		pthread_cancel:void**当中保存了一个常数PTHREAD_CANCELED
返回值：
	成功返回0，失败返回错误码。

注意：调用该函数的执行流在等待线程退出的时候，该执行流是阻塞在pthread_join函数中的
代码：

  #include <stdio.h>                                                                             
  #include <pthread.h>
  #include <unistd.h>
  
  #define PTHREADCOUNT 1
  
 void* myPthread(void* arg)
  {
    while(1)
    {
      printf("I am workthream!\n");
      sleep(1);
      pthread_cancel(pthread_self());
    }
  
  }
  int main()
  {
    pthread_t tid[PTHREADCOUNT];
    for(int i = 0;i < 1;i++)
    {
      int ret = pthread_create(&tid[i],NULL,myPthread,NULL);
      if(ret < 0)
      {
        printf("pthread_create");
        return -1;
      }
      for(int i = 0;i < PTHREADCOUNT;i++)
      {
        pthread_join(tid[i],NULL);
      }
      while(1)
        {
        printf("I am main thread!\n");
        sleep(6);
        printf("exit\n");
        pthread_cancel(pthread_self());
      }
    }
    return 0;
  }

运行结果：
在这里插入图片描述
这个程序主线程会阻塞在pthread_join函数,直到工作线程退出以后，才继续往下执行，也就不会产生僵尸进程了。

线程分离

与线程等待相对应的就是线程分离，线程分离的作用就是改变线程的属性，将joinable属性改为detach属性，这样，当线程退出的时候就不需要其它线程来回收退出线程的资源，操作系统会默认回收掉。
线程分离我们使用的函数叫pthread_detach

函数原型：
 #include <pthread.h>

 int pthread_detach(pthread_t thread);
 参数解释：
 	thread：想要被分离线程的线程标识符
 返回值：成功返回0，失败返回错误码

代码：

  #include <stdio.h>                                                                             
  #include <pthread.h>
  #include <unistd.h>
  
  #define PTHREADCOUNT 1
  
 void* myPthread(void* arg)
  {
    while(1)
    {
      printf("I am workthream!\n");
      sleep(1);
      pthread_cancel(pthread_self());
    }
  
  }
  int main()
  {
    pthread_t tid[PTHREADCOUNT];
    for(int i = 0;i < 1;i++)
    {
      int ret = pthread_create(&tid[i],NULL,myPthread,NULL);
      if(ret < 0)
      {
        printf("pthread_create");
        return -1;
      }
      for(int i = 0;i < PTHREADCOUNT;i++)
      {
        pthread_detach(tid[i],NULL);
      }
      while(1)
        {
        printf("I am main thread!\n");
        sleep(6);
      }
    }
    return 0;
  }

运行结果：
在这里插入图片描述

℃绝心恋
关注
  • 5
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
LinuxC应用开发学习笔记（十四）—管道算法和进程间通信
梅山
01-12 432
管道算法和进程间通信 管道的实现 #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <sys/wait.h> #define BUFSIZE 1024 int main() { int pd[2],len = 0; __pid_t pid; char buf[BUFSIZE]; if(pipe(pd)<0) {
Linux程序设计第二版练习题（第五章）
Junhao的博客
10-31 7302
很久以前的学习过的一本书，这部书比较基础。 以下只是个人的做法，仅供参考。 1、设计一个程序，要求打开文件“pass“，如果没有这个文件，权限设置为只有所有者有只读权限。 #include &lt;unistd.h&gt; #include &lt;stdlib.h&gt; #include &lt;stdio.h&gt; #include &lt;sys/types.h&gt; #include...
IO进程线程（八）线程(pthread_t)
最新发布
weixin_44254079的博客
06-08 810
线程
linux——线程（2）
zxr916的博客
07-06 145
文章目录1.pthread_join 函数2.pthread_detach 函数3.pthread_cancel 函数4.终止线程方式5.控制原语对比6.线程属性7.线程属性初始化8.线程的分离状态9.线程使用注意事项 1.pthread_join 函数 阻塞等待线程退出，获取线程退出状态 其作用，对应进程中 waitpid() 函数。 int pthread_join(pthread_t thread, void **retval); 成功：0；失败：错误号 参数：thread：线程 ID （【注
进程间通讯
u010518627的博客
04-18 268
文章目录Linux 下进程间通信概述无名管道管道创建与关闭 create pipe - `pipe`管道的读写FIFO信号通信信号发送与捕捉信号的处理 ANSI C signal handling - `signal`共享内存IPC对象共享内存实现共享内存举例消息队列典型的基于 `msq` 的 CS 模型消息队列举例信号灯`sem` 函数信号灯的典型应用进程间通讯方式比较 Linux 下进程间通信概述 进程间通信：进程在用户空间内是相互独立的，无法在用户空间内进行通信。但是它们都可以访问内核，那么它们可
系统编程第五节——线程
lianggoch的博客
07-28 340
一、线程的概念 1、进程 进程就是正在系统中运行的程序。 程序被运行时，会被系统从硬盘加载到内存中，进程会在内存中形成一个独立的内存体，这个内存体有自己的堆，栈，数据段，代码段等资源。进程的上级挂靠操作系统。 进程是系统中资源分配的最小单位！ 2、线程 线程是比进程更小的单位，在操作系统中不能独立存在，线程必须要存在于进程中。一个进程里面至少有一条线程(主线程)，线程是系统中任务调度的最小单位，简单来说，线程就是用来干活的。 线程是系统中任务调度的最小单位！ 操作系统： 一家公司 进程：公司里面的部门 线程
趣谈Linux第十章：线程的数据描述
10-29
2. **线程控制块 (Thread Control Block, TCB)**: TCB存储了线程状态、调度信息、寄存器状态等关键数据。在Linux中，TCB是`task_struct`结构的一部分，包含了与线程相关的所有信息。 3. **栈**: 每个线程都有自己...
基于linux的进程和线程控制
02-01
对于线程控制，Linux提供了pthread库，它包含了一系列函数来创建、销毁、同步和通信线程。例如，pthread_create()用于创建新线程，pthread_join()用于等待线程结束，pthread_mutex_lock()和pthread_mutex_unlock()...
Linux系统下的多线程编程入门.pdf
12-20
本文将深入探讨Linux环境中的多线程概念、创建与管理线程的方法、线程同步与通信机制，以及多线程编程中可能遇到的问题和解决策略。 一、多线程概念 多线程是指在一个进程中可以同时执行多个独立的代码段，每个代码...
Linux下的多线程编程实例解析
09-14
【Linux下的多线程编程实例解析】 在计算机操作系统中，多线程编程是实现并行处理和提高系统效率的一种重要技术。Linux系统同样支持多线程编程，这使得开发者能够利用这一特性创建高效的、响应迅速的应用程序。多...
Linux多线程实现令牌桶流量控制
02-19
本文将深入探讨如何在Linux环境下利用多线程技术来实现令牌桶流量控制。 首先，我们要理解令牌桶算法的基本原理。令牌桶算法是一个允许突发数据传输并同时保持平均传输速率的机制。桶中存储一定数量的令牌，只有当...
进程通信1
sunflowers_JIN的博客
05-11 197
printf("写入： %d。printf("读取： %d。// 将共享内存区附加到进程地址空间。// 子进程（写进程）// 父进程（读进程）// 分离共享内存区并删除它。// 创建共享内存区。
Linux多线程编程
长期更新Java自学笔记
01-06 2043
线程同步： 多线程环境中，无论调度顺序怎么样，都能得到我们想要的结果 同步的方法： 信号量、互斥锁、条件变量、读写锁 互斥锁只能用于互斥型场景，它的作用等同于二值（0/1）信号量的作用 pthread_create：创建并启动线程 pthread_exit：退出线程 #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <string.h> #include <pthre
LinuxC应用开发学习笔记（八）—系统调用I/O
梅山
12-21 938
UNIX环境高级编程（APUE） 文件系统 四、六、七章 I/0 3-5章、14章 文件I/O 标准I/O 并发 信号10章节 多进程并发 多线程并发10-11章节 IPC：进程间通信 8章节 进程基础（涉及到多进程） 13章 守护进程 15-16章 注意事项： 1、弃用root用户 2、重构代码 3、课堂重点：项目，课堂代码，面试题，实验性题目，推荐书籍课后题 I/O：input & output，是一切实现的基础 标准io：stdio 依赖于sysio 系统调用io：sysio（文件IO） 优先
Linux进程控制
weixin_44395170的博客
11-05 151
学习进程创建, 等待, 终止. 使用代码实现. 编写自主shell. 封装fork/wait等操作, 编写函数 process_create(pid_t* pid, void* func, void* arg), func回调函数就是子进程执行的入口函数, arg是传递给func回调函数的参数. 调研popen/system, 理解这两个函数和fork的区别. ...
linux程序设计笔记--pthread--semaphore
zhangxiaopeng0829的专栏
04-08 1103
<!-- @page {margin:0.79in} p {margin-bottom:0.08in} --> 多线程的同步机制  实现线程同步机制：信号量和互斥量。  信号量：  #include  intsem_init(sem_t *sem,int pshared,unsigned int value);//信号量的初始化。  sem_t*sem：信号量
Linux应用程序开发笔记：SCHED_RR模式线程调度测试
u010018991的博客
08-19 971
测试代码： #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <pthread.h> #include <semaphore.h> static sem_t sem; static sem_t lock; static void *pthread_fun1(void *arg) { int cnt = 0; .
LInux线程条件变量的使用
学无止境
04-09 1708
/* *生产者消费者问题 * */#include&lt;stdio.h&gt;#include&lt;string.h&gt;#include&lt;stdlib.h&gt;#include&lt;unistd.h&gt;#include&lt;pthread.h&gt;#define MAX_STOCK 20//仓库容量char g_storage[MAX_STOCK];size_t g_st...
信号量解决生产者-消费者问题
qzk1993的博客
08-12 1389
信号量 生产者-消费者问题

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值