Linux多线程的创建和结束

已于 2024-08-02 17:27:17 修改
阅读量1.7k 收藏
点赞数 2
文章标签： c语言
于 2021-08-14 17:21:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yys197/article/details/119700794
版权

线程，是一个并发的执行流程，一般称之为轻量级的进程。

线程从属于创建他的进程，不和进程分离，共享进程资源。

创建线程的进程结束了，该进程的所有简称都结束（皮之不存毛将焉附）。

线程是cpu最小的执行单元。

线程的创建：

//Linux Programmer`s Manual
#include<pthread.h>

int pthread_create(pthread_t *thread,const pthread_attr_t *attr,
                void *(*start_routine) (void *),void *arg);//创建一个新的线程

/*
参数1：线程的标识符（其实就是int）  参数2：设置线程的属性（分离or非分离）
参数3：线程要执行的函数（返回值和形参类型都固定死了（void *））
参数4：线程执行的时候，要传给线程的参数。

compile and link with -pthread  编译的时候要加上 -pthread
eg:    gcc text.c -o s -pthread

成功返回0。
失败返回一个参数编号error number。
没有对全局错误变量设置值，不能用perror打印错误信息。（perror->errno）
可以把error number传到strerror()中获得错误信息。

分离：线程结束后，（进程）进行资源回收。
非分离：（进程）不进行资源回收。
*/

测试1： 主进程和2个线程并发执行>>>>>>>>>>>>>线程的创建。

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

void *thread_one(void *arg)
{
    int num = (int)arg;
    while(num > 0)
    {
        printf("int thread one ->%d\n",num--);
        sleep(1);
    }
    return NULL;
}

void *thread_two(void *arg)
{
    int num = (int)arg;
    while(num > 0)
    {
        printf("int thread two ->%d\n",num--);
        sleep(1);
    }
    return NULL;
}

int main(void)
{
    //线程的标识
    pthread_t one;        //线程的标识符 long unsigned int
    //参数2：设置线程的属性，分离，栈空间大小，优先级，调度策略..
    //参数3：执行函数
    //参数4：成功为0，失败为错误编号：注意 不是errno
    int ret = pthread_create(&one,NULL,thread_one,(void*)10);
    if(0 != ret)
    {
        printf("create thread one failed --> %s\n",strerror(ret));
    //strerror()捕获错误信息，以字符串str类型返回。
    //他不会设置全局错误变量，所以perror不能用。
    //因为线程的创建函数不属于 系统调用，属于 用户层 的函数，所以不会对errno进行设置。
        exit(EXIT_FAILURE);
    }
    printf("pthread_one=%lu\n", one);
    pthread_t two;   
    int ret = pthread_create(&two,NULL,thread_two,(void*)15);
    if(0 != ret)
    {
        printf("create thread one failed --> %s\n",strerror(ret));    
        exit(EXIT_FAILURE);
    }

    int i = 0;
    //进程称之为主线程。
    while(1)
    {
        printf("in main while -->%d\n",++i);
        sleep(1);
    ｝                      //第三个并发的执行流程。
    return 0;
}

测试2：线程的结束。

线程的结束方式：

1，线程函数执行完了，运行return返回  （寿终正寝）

2，线程运行过程中，满足某个条件提前结束，pthread_exit （吊日子过不下去了）

3，线程A 收到 线程B 发送的结束请求，默认情况下，会结束执行结束请求，提前结束（谋害）

4，同归于尽的结束方式：在线程中调用exit。

1、2都是内部结束，3是外部结束。

线程结束处理：

线程有运行代码，有栈空间，TCB(线程控制块)，线程号等...

线程结束后，需要对其进行资源回收。

---->pthread_join:阻塞等待指定的线程结束，并对其进行资源回收。

可以通过pthread_join 获得线程的返回值。

//man手册中的pthread_join
#include<pthread.h>
int pthread_join(pthiread_t thread,void **retval);

 正常结束return：

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

void *thread_one(void *arg)
{
    int num = (int)arg;
    while(num > 0)
    {
        printf("int thread one ->%d\n",num--);
        sleep(1);
    }
    return (void* 66);
}

int main(void)
{
    //线程的标识
    pthread_t one;        
    int ret = pthread_create(&one,NULL,thread_one,(void*)5);
    if(0 != ret)
    {
        printf("create thread one failed --> %s\n",strerror(ret));
        exit(EXIT_FAILURE);
    }
    printf("pthread_one =%lu\n",one);

    //阻塞等待指定的线程结束，并对其进行资源回收
    void *retval=NULL;
    pthread_join(one,&retval);
    printf("thread retval = %d\n",(int)retval);

    int i = 0;
    //进程称之为主线程。
    while(1)
    {
        printf("in main while -->%d\n",++i);
        sleep(1);
    ｝                      //第三个并发的执行流程。
    return 0;
}

非正常结束：

pthread_exit();

//man手册
#include<pthread.h>
void pthread_exit(void *retval);
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<pthread.h>

void *thread_one(void *arg)
{
    int num = (int)arg;
    while(num > 0)
    {
        printf("int thread one ->%d\n",num--);
        sleep(1);
        if(2==num)
        {
            //结束线程本身，不影响其他。
            pthread_exit((void*)88);
        }
    }
    printf("end of thread\n");
    return (void* 66);
}

int main(void)
{
    //线程的标识
    pthread_t one;        
    int ret = pthread_create(&one,NULL,thread_one,(void*)5);
    if(0 != ret)
    {
        printf("create thread one failed --> %s\n",strerror(ret));
        exit(EXIT_FAILURE);
    }
    printf("pthread_one =%lu\n",one);

    //阻塞等待指定的线程结束，并对其进行资源回收
    void *retval=NULL;
    pthread_join(one,&retval);
    printf("thread retval = %d\n",(int)retval);

    int i = 0;
    //进程称之为主线程。
    while(1)
    {
        printf("in main while -->%d\n",++i);
        sleep(1);
    ｝                      //第三个并发的执行流程。
    return 0;
}

结束请求：

pthread_cancel();

//man手册
#include <pthread.h>
int pthread_cancel(pthread_t thread);

//成功返回0 失败返回 nonzero error number
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<pthread.h>

void *thread_one(void *arg)
{
    int i = 0;
    while(1)
    {
        printf("int thread one ->%d\n",++i);
        sleep(1);
    }
    return (void* 66);
}

int main(void)
{
    //线程的标识
    pthread_t one;        
    int ret = pthread_create(&one,NULL,thread_one,NULL);
    if(0 != ret)
    {
        printf("create thread one failed --> %s\n",strerror(ret));
        exit(EXIT_FAILURE);
    }
    printf("pthread_one =%lu\n",one);

    int i = 0;
    //进程称之为主线程。
    while(1)
    {
        printf("in main while -->%d\n",++i);
        sleep(1);
        
        if(5 == i)
        {
            //向指定的线程发出结束请求
            pthread_cancel(one);   
        }
    ｝                      //第三个并发的执行流程。
    return 0;
}

线程对请求的处理：

pthread_setcaacelstate();

pthread_setcancelstate();

//man
#include<pthread.h>
int pthread_setcancelstate(int state,int *oldstate);
state:PTHREAD_CANCEL_ENABLE  允许接收请求（默认）
      PTHREAD_CANCEL_DISABLE   阻塞
*oldstate: 是否要保存原先的state yes:任意int  no:给NULL
返回值：成功返回0  不成功返回 nonzero error number


int pthread_setcanceltype(int type,int *oldtype);
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<pthread.h>

void *thread_one(void *arg)
{
    int i = 0;
    //收到的请求将会被阻塞，直到cancel的状态被设置为ENABLE
    pthread_setcancelstate(PTHREAD_CANCEL_DISABLE,NULL);
    while(1)
    {
        printf("int thread one ->%d\n",++i);
        sleep(1);
        if(15 == i)
        {
            printf("15s解除阻塞..\n");
            pthread_setcancelstate(PTHREAD_CANCEL_ENABLE,NULL);
        }
    }
    return (void* 66);
}

int main(void)
{
    //线程的标识
    pthread_t one;        
    int ret = pthread_create(&one,NULL,thread_one,NULL);
    if(0 != ret)
    {
        printf("create thread one failed --> %s\n",strerror(ret));
        exit(EXIT_FAILURE);
    }
    printf("pthread_one =%lu\n",one);

    int i = 0;
    //进程称之为主线程。
    while(1)
    {
        printf("in main while -->%d\n",++i);
        sleep(1);
        
        if(5 == i)
        {
            //5S向指定的线程发出结束请求
            printf("发送结束请求..\n");
            pthread_cancel(one);   
        }
    ｝                      //第三个并发的执行流程。
    return 0;
}

线程属性的设置：

1.分离线程/非分离：

pthread_detach();//设置分离

//man
#include<pthread.h>
int pthread_detach(pthread_t thread);
//设置线程为分离线程，分离的线程结束后，资源自动回归系统，不需要等待资源回收
//如果分离一个已经分离的线程 会发生未知行为

成功返回0  不成功返货 nonzero error number

   //获得线程号 

    pthread_self()
    pthread_detach(pthread_self());//设置分离

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

void *thread_one(void *arg)
{
    pthread_detach(pthread_self());
    int i = 0;
    while(num > 0)
    {
        printf("int thread one ->%d\n",++i);
        sleep(1);
        if(5==i)
        {
            break;
        }
    }
    return (void* 66);
}

int main(void)
{
    //线程的标识
    pthread_t one;        
    int ret = pthread_create(&one,NULL,thread_one,(void*)5);
    if(0 != ret)
    {
        printf("create thread one failed --> %s\n",strerror(ret));
        exit(EXIT_FAILURE);
    }
    printf("pthread_one =%lu\n",one);

    //阻塞等待指定的线程结束，并对其进行资源回收
    void *retval=NULL;
    pthread_join(one,&retval);
    printf("thread retval = %d\n",(int)retval);
    
    int i = 0;
    //进程称之为主线程。
    while(1)
    {
        printf("in main while -->%d\n",++i);
        sleep(1);
    ｝                      //第三个并发的执行流程。
    return 0;
}

以上程序还是join成功了，因为线程创建成功后，会先执行join（不能在join前sleep(1),若sleep(1)的话，会让出CPU去执行线程，就会先执行detach。然后再执行join），再执行detach！（detach写入线程内部的情况）

join失败：

在join之前设置线程分离。

    pthread_detache(one);
    //阻塞等待指定的线程结束，并对其进行资源回收
    void *retval=NULL;
    pthread_join(one,&retval);
    printf("thread retval = %d\n",(int)retval);

**也可以在创建的时候 直接设置分离属性：

设置分离属性函数：pthread_attr_setdetachstate();

//man
#include<pthread.h>
pthread_attr_setdetachstate(pthread_attr_t *attr,int detachstate);

//detachstate:PTHREAD_CREATE_DETACHED
              PTHREAD_CAEATE_DETACHED

pthread_attr_getdetachstate(pthread_attr_t *attr,int detachstate);//获得分离属性
pthread_attr_t attr; //设置属性的变量
pthread_attr_init(&attr);//初始化
pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);//生成分离属性
int ret = pthread_create(&one,&attr,thread_one,NULL);//设置分离

设置优先级：

//man
#include<pthread.h>
int pthread_attr_setschedparam(pthread_attr_t *attr,const struct sched_param *param);

int pthread_attr_getschedparam(pthread_attr_t *attr,const struct sched_param *param);

struct sched_param{
    int sched_priority; //根据这个整数来确定优先级
}
pthread_attr_t attr; //设置属性的变量
pthread_attr_init(&attr);//初始化

struct sched_param param;
param.sched_priority = ;

pthread_attr_setschedparam(&attr,&param);
if(0 != errnum)
{
    printf("设置优先级失败--->%s\n",strerror(errnum));
    exit(EXIT_FAILURE);
}

/*------------------------------------------------------------------------------------*/

笔记从2021.8.14开始记录。

什么都想学的阿松
关注
Linux之线程创建及终止
qq_59969777的博客
08-21 837
Linux之线程创建及终止 线程创建 线程挂起 线程终止
Linux 多线程原理深剖
热门推荐
qq_61500888的博客
12-24 4万+
带你一命通关 Linux 多线程原理 三十分钟手撕底层内涵
linux 多线程的创建和取消
aaa2540567665的博客
08-02 160
linux 多线程的创建和取消。
Linux线程处理—线程创建
最新发布
weixin_45706195的博客
09-16 815
每个线程都有一个唯一的标识符（即线程 ID），这个标识符是通过 pthread_t 类型 的变量来表示的，当 pthread_create 成功创建一个线程时，它会将新线程的标识符存储 在 thread 参数指向的位置。是 POSIX 线程（也称为 pthreads）库中一个重要的函数，它用于等待一个线程的终止。当一个线程被创建后，它可能会并行地执行自己的任务，而主线程（或其他线程）可能需要等待这个线程完成其任务后才能继续执行。函数就提供了这样的同步机制。
linux 线程的创建和终止,linux高编线程-------线程的创建，终止
weixin_32021363的博客
05-10 208
Q： what is thread ?A：一个正在运行的函数----是运行函数咯----多线程共享内存空间咯posix线程是一套标准，而不是实现线程标识： pthread_t 类型不确定：结构体？or指针？or整型数，想啥是啥，可以自己定义咯lhh@lhh:~$ ps axmlhh@lhh:~$ ps ax -L // LWP进程就是容器 内部装载线程函数：int pthread_equ...
嵌入式Linux系统编程学习之二十七线程的创建和退出
PoroKing的博客
11-18 1048
  创建线程实际上就是确定调用该线程函数的入口点，线程的创建采用函数 pthread_create 。在线程创建以后，就开始运行相关的线程函数，在该函数运行完之后，线程就退出，这也是线程退出的一种方式。另一种线程退出的方式是使用函数 pthread_exit ，这是线程主动退出行为。这里需要注意的是，在使用线程函数时，不能随意使用 exit 退出函数进行出错处理，由于 exit 的作用是使调用进程终止，往往一个进程包括了多个线程，所以线程中通常使用 pthread_exit 函数来代替进程中的退出函数 ex
【Linux】线程概述、创建线程、终止线程
mhyasadj的博客
05-29 983
线程概述、创建线程、终止线程
实验二：Linux多线程创建.docx
04-13
Linux 多线程创建实验 本实验的目的是为了进一步掌握在 Linux 系统进行 C 语言编程的方法，进一步了解线程的概念，进一步理解进程与线程的概念，并掌握 C 语言线程创建的方法。 实验原理： 1. Pthread_create ...
Linux系统下的多线程编程入门.pdf
12-20
在Linux系统下进行多线程编程是开发高效并发应用程序...理解和掌握线程创建、同步、通信和问题处理，是编写高效、可靠的多线程程序的基础。通过不断实践和学习，我们可以驾驭这一强大的工具，提升软件性能和用户体验。
linux_code.rar_linux 多线程_linux 线程_多线程编程
09-14
在Linux系统中，多线程编程是实现高效并发执行任务的一...总的来说，这份压缩包为学习Linux多线程编程提供了宝贵的实践材料，通过深入研究这些源码，你可以更好地理解和掌握多线程在Linux环境中的工作原理和最佳实践。
linux多线程编程.pdf
10-09
Linux多线程编程是操作系统中并发程序设计的一个重要领域，它允许开发者在同一程序中创建多个线程，以实现并行执行，从而提高程序的执行效率和响应能力。Linux下的多线程编程通常基于POSIX线程（pthread）库来实现，...
Linux Qt下简单的多线程编程例子
03-11
Linux Qt下简单的多线程编程例子，具体内容可以参考文章http://blog.csdn.net/maxwell_nc/article/details/44198811
嵌入式Linux-线程创建与终止
weixin_52694360的博客
01-21 1692
启动程序时，创建的进程只是一个单线程的进程，称之为初始线程或主线程，本小节我们讨论如何创建一个新的线程。注意pthread_create()在调用失败时通常会返回错误码，它并不像其它库函数或系统调用一样设置errno，每个线程都提供了全局变量errno的副本，这只是为了与使用errno到的函数进行兼容，在线程中，从函数中返回错误码更为清晰整洁，不需要依赖那些随着函数执行不断变化的全局变量，这样可以把错误的范围限制在引起出错的函数中。
linux线程创建和销毁时间,linux内核线程的创建与销毁
weixin_39630637的博客
05-04 405
linux将创建内核线程的工作交给了一个专门的内核线程kthreadd来完成，该线程会检查全局链表kthread_create_list，如果为NULL，就会调schedule()放弃cpu进入睡眠状态，否则就取下该链表中的一项创建对应的线程。本文就从khtreadd内核线程的创建开始来展示一下内核线程的创建过程。1kthreaddlinux2.6.30，创建内核线程是通过kethradd内核守...
linux线程创建和销毁
xmuyong的专栏
05-26 1万+
基本函数介绍 创建线程 int ptread_create(pthread_t *thread, const pthread_att_t *attr, void * (*start)(void *), void *arg) 返回值 参数 thread pthread_t 类型的缓冲区，在创建函数返回前，会在此保存一个该线程的唯一标识。 attr 线程属性...
Linux线程创建、销毁、终止与栈清理
yolo_yyh的博客
08-05 2838
目录 一、线程的概念 二、线程的创建 三、线程的终止与栈清理 1、线程终止 2、栈的清理 四、线程取消 五、线程分离 六、线程同步 一、线程的概念 线程就是一个正在运行的函数，不同的平台有不同的线程标准，posix 线程是一套标准，而不是实现； 线程标识：pthread_t，不要用%d直接打印，如果想判断线程 id 可以用 pthread_equal 非零表示相等，pthread_self 返回当前线程号； 二、线程的创建 pthread_create(pthread_t*, co
【Linux】详解线程控制之线程创建&线程终止&线程等待&线程分离
m0_74265792的博客
05-18 1858
【Linux】详解线程控制之线程创建、线程终止、线程等待、线程分
Linux 内核线程的创建与销毁
raoxu1154492168的博客
03-15 265
Linux 内核线程的创建与销毁
多线程_终止
weixin_43003240的博客
02-21 263
package com.sxt.state; /** * 终止线程 1、线程正常执行完毕--&amp;gt;次数 2、外部干涉--&amp;gt;加入标识 不要使用stop、destroy * * @author * */ public class TerminateThread implements Runnable { // 1、加入标识 标记线程体是否可以运行 private boole...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值