linux高级编程笔记（七）——线程

最新推荐文章于 2023-05-15 17:41:06 发布
最新推荐文章于 2023-05-15 17:41:06 发布
阅读量175 收藏
点赞数
分类专栏： linux系统编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_23413535/article/details/114226808
版权

目录

一、线程概念

1 线程和进程的关系

2 线程间共享资源 

3 线程非共享资源 

4 优缺点

二、进程控制原语

1 pthread_create函数

2 pthread_self函数

3 pthread_exit函数

4 pthread_join函数

5 pthread_detach函数

6 pthread_cancel函数

7 pthread_equal函数

三、线程属性

1 线程属性初始化

2 线程的分离状态

3 线程的栈空间

四、NPTL

五、线程使用注意事项

一、线程概念

1 线程和进程的关系

  • 轻量级进程（light-weight process），也有PCB，创建线程使用的底层函数和进程一样，都是clone
  • 从内核里看进程和线程是一样的，都有各自不同的PCB，但是同一进程的各个线程PCB中指向内存资源的三级页表是相同的
  • 进程可以蜕变成线程
  • 在美国人眼里，线程就是寄存器和栈
  • 在linux下，线程最是小的执行单位；进程是最小的分配资源单位

查看进程的LWP（线程号）

ps -Lf pid
ps -eLf

2 线程间共享资源 

  • 文件描述符表
  • 每种信号的处理方式（减少多线程程序中使用信号）
  • 当前工作目录
  • 用户ID和组ID
  • 内存地址空间（.text/.data/.bss/heap/共享库）

3 线程非共享资源 

  • 线程id
  • 处理器现场和栈指针（内核栈）
  • 独立的栈空间（用户空间栈）
  • errno变量
  • 信号屏蔽字
  • 调度优先级 

4 优缺点

优点：

  • 提高程序的并发性
  • 开销小，不用重新分配内存
  • 通信和共享数据方便

 缺点：

  • 线程不稳定（库函数实现）
  • 线程调试比较困难（gdb支持不好）
  • 对信号支持不好

二、进程控制原语

1 pthread_create函数

 #include <pthread.h>
 int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
                          void *(*start_routine) (void *), void *arg);

描述：

创建一个线程

参数：

thread 传出参数，获得当前创建的线程的唯一标识

attr 线程属性设置，如使用默认属性，则传NULL

start_routine 函数指针，指向新线程应该加载执行的函数模块

arg 指定线程将要加载调用的那个函数的参数

返回：

如果成功，pthread_create()返回0；发生错误时，它返回一个错误号，*thread的内容是未定义的

2 pthread_self函数

#include <pthread.h>
pthread_t pthread_self(void);

描述：

这个函数总是成功的，返回调用线程的ID。

注意：

  • 线程 ID为pthread_t类型，在 Linux 下为无符号整数(%lu)，其他系统中可能是结构体实现。
  • 线程ID是进程内部，识别标志(两个进程间，线程ID允许相同)。在进程间应该用LWP号来区别不同的线程。
  • 不应使用全局变量pthread_t tid，在子线程中通过 pthread_create传出参数来获取线程ID，而应使用pthread_self。

示例代码 ：

#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <error.h>
#include <stdlib.h>//exit
#include <string.h>//stderr

void * tfn(void *arg)
{
        printf("tfn -- pid = %d, tid = %lu\n",getpid(),pthread_self());

        return (void*)0;
}

int main()
{
        pthread_t tid;
        printf("main -- pid = %d, tid = %lu\n",getpid(),pthread_self());

        int ret = pthread_create(&tid,NULL,tfn,NULL);

        if(ret!=0)
        {
                fprintf(stderr,"pthread create error: %s\n",strerror(ret));
                exit(1);
        }

        sleep(1);

        return 0;
}

#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <error.h>
#include <stdlib.h>//exit
#include <string.h>//stderr

void * tfn(void *arg)
{

        int i = (int) arg;

        printf("#%d tfn -- pid = %d, tid = %lu\n",i,getpid(),pthread_self());

        return (void*)0;
}

int main()
{
        pthread_t tid;
        printf("main -- pid = %d, tid = %lu\n",getpid(),pthread_self());

        int i;
        
        for(i=0;i<5;i++)
        {
            int ret = pthread_create(&tid,NULL,tfn,(void *)i);
    
            if(ret!=0)
            {
                fprintf(stderr,"pthread create error: %s\n",strerror(ret));
                exit(1);
            }
        }      

        return 0;
}

3 pthread_exit函数

在多进程程序中，可以使用exit退出。而在多线程下，使用exit会将整个进程退出，导致一些没有运行完毕的线程都结束。即使使用return只会退出当前的函数，也无法正确退出。因此，在多线程中，应该使用pthread_exit函数。在之前的代码示例中，main函数退出时，会退出整个进程，因此，未执行完毕的线程也都退出。因此，应该使用pthread_exit退出主线程，这样子线程将会继续执行完毕。

#include <pthread.h>
void pthread_exit(void *retval);

4 pthread_join函数

#include <pthread.h>
int pthread_join(pthread_t thread, void **retval);//回收线程，retval为线程的返回值。成功返回0，失败返回-1。

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

typedef struct{
        int var;
        char str[64];
} exit_t;

void * tfn(void *arg)
{
        exit_t * ret;
        ret = malloc(sizeof(exit_t));
        ret->var = 77;
        strcpy(ret->str,"hello world");
        return (void*) ret;
}

int main()
{
        pthread_t tid;
        exit_t * ret;

        pthread_create(&tid,NULL,tfn,NULL);
        pthread_join(tid,(void**)&ret);//回收线程

        printf("pthread var = %d, str = %s\n",ret->var,ret->str);

        return 0;
}

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

typedef struct{
        int var;
        char str[64];
} exit_t;

void * tfn(void *arg)
{
        exit_t * ret;
        ret = malloc(sizeof(exit_t));
        ret->var = (int) arg;
        strcpy(ret->str,"hello world");
        return (void*) ret;
}

int main()
{
        pthread_t tid[5];
        exit_t * ret[5];
        int i;

        for(i=0;i<5;i++)
        {
            pthread_create(&tid[i],NULL,tfn,(void *) i);

        }

        for(i=0;i<5;i++)
        {
            pthread_join(tid[i],(void**)&ret[i]);//回收线程,回收完毕才会往下执行
            printf("pthread var = %d, str = %s\n",ret[i]->var,ret[i]->str);
        }

        return 0;
}

5 pthread_detach函数

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

void * tfn(void *arg)
{
        int n = 5;
        while(n--)
        {
                printf("pthread tfn n = %d\n",n);
                sleep(1);
        }
        return (void*) 7;
}

int main()
{
        pthread_t tid;
        void * ret;
        
        pthread_create(&tid,NULL,tfn,NULL);
        pthread_detach(tid);//将线程分离出来，不需要父进程回收

        int retval = pthread_join(tid,(void**) &ret);

        if(retval != 0)//由于子线程已经分离出来了。因此，会报错
        {
                fprintf(stderr,"pthread_join error %s\n", strerror(retval));
        }
        else
        {
                printf("pthread exit with %d\n",(int)ret);
        }

        return 0;
}

6 pthread_cancel函数

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

void * tfn1(void *arg)
{
        printf("thread 1 exiting\n");
        return (void*) 111;
}

void * tfn2(void *arg)
{
        printf("thread 2 exiting\n");
        return (void*) 222;
}

void * tfn3(void *arg)
{

        while(1)
        {
                printf("thread 3. I'm going to die...\n");
                sleep(1);
        }
}

int main()
{
        pthread_t tid;
        void * ret;
        int i;

        pthread_create(&tid,NULL,tfn1,NULL);
        pthread_join(tid,&ret);
        printf("thread 1 exit code = %d\n",(int)ret);

        pthread_create(&tid,NULL,tfn2,NULL);
        pthread_join(tid,&ret);
        printf("thread 2 exit code = %d\n",(int)ret);

        pthread_create(&tid,NULL,tfn3,NULL);
        sleep(3);

        //杀死子线程，需要线程有取消点（系统调用等），由于tfn3中有printf,该函数会调用write，
        //所以可以取消，如果去掉有系统调用的逻辑，该线程不会被取消
        pthread_cancel(tid);
        pthread_join(tid,&ret);
        printf("thread 3 exit code = %d\n",(int)ret);//线程3由于已经被杀死了，ret此时为-1

        return 0;
}

7 pthread_equal函数

int pthread_equal(pthread_t t1, pthread_t t2);//比较两个线程是否相等

三、线程属性

typedef struct
{
    int etachstate; //线程的分离状态，可以实现与pthread_detach一样的功能
    int schedpolicy; //线程调度策略
    structsched_param schedparam; //线程的调度参数
    int inheritsched; //线程的继承性
    int scope; //线程的作用域
    size_t guardsize; //线程栈末尾的警戒缓冲区大小
    int stackaddr_set; //线程的栈设置
    void* stackaddr; //线程栈的位置。栈的低地址
    size_t stacksize; //线程栈的大小。默认为每一个线程平均分配栈空间（8M）
}pthread_attr_t;

1 线程属性初始化

属性值不能直接设置，须使用相关函数进行操作，初始化的函数为pthread_attr_initI这个函数必须在pthread_create函数之前调用。之后须用pthread_attr_destroy函数来释放资源。

线程属性主要包括如下属性：作用域(scope)、栈尺寸(stack size)、栈地址(stack address)、优先级(priority)、分离的状态(detached state)、调度策略和参数(scheduling policy and parameters)。默认的属性为非绑定、非分离、缺省的堆栈、与父进程同样级别的优先级。

#include <pthread.h>

int pthread_attr_init(pthread_attr_t *attr);
int pthread_attr_destroy(pthread_attr_t *attr);

2 线程的分离状态

#include <pthread.h>

int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate);
int pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detachstate);

参数：

attr 已初始化的线程属性

detachstate PTHREAD_CREATE_DETACHED（分离线程）

                    PTHREAD_CREATE_JOINABLE（非分离线程）

代码示例：

#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h> //%s

void * tfn(void * arg)
{
        while(1)
        {
                printf("thread - tfn - ");
                sleep(1);
        }
}

int main()
{
        pthread_t tid;
        void * tret;

        pthread_attr_t attr;

        pthread_attr_init(&attr);
        pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);

        pthread_create(&tid,&attr,tfn,NULL);
        pthread_attr_destroy(&attr);

        int ret;
        while(1)
        {
                ret = pthread_join(tid,(void **)&tret);
                if(ret !=0 )
                {
                        fprintf(stderr,"thread %s\n", strerror(ret));
                }
                else
                {
                        printf("thread - main -\n");
                }
                sleep(1);
        }

        return 0;
}

3 线程的栈空间

#include <pthread.h>

int pthread_attr_setstack(pthread_attr_t *attr,
                                 void *stackaddr, size_t stacksize);
int pthread_attr_getstack(const pthread_attr_t *attr,
                                 void **stackaddr, size_t *stacksize);

参数:

attr 指向一个线程属性的指针

stackaddr 返回获取的栈地址

stacksize 返回获取的栈大小

代码示例：

#include <stdio.h>
#include <pthread.h>
#include <string.h>
#include <stdlib.h>
#define SIZE 0x10000

int print_ntimes(char *str)
{
    sleep(1);
    printf("%s\n", str);
    return 0;
}

void *th_fun(void *arg)
{
    int n = 3;
    while (n--) print_ntimes("hello th_fun\n");
}

int main(void)
{
    pthread_t tid;
    int err, detachstate, i = 1;
    pthread_attr_t attr;
    size_t stacksize;
    void *stackaddr;
    pthread_attr_init(&attr);
    pthread_attr_getstack(&attr, &stackaddr, &stacksize);
    printf("stackadd=%p\n", stackaddr);
    printf("stacksize=%x\n", (int)stacksize);
    pthread_attr_getdetachstate(&attr, &detachstate);

    if (detachstate == PTHREAD_CREATE_DETACHED)
        printf("thread detached\n");
    else if (detachstate == PTHREAD_CREATE_JOINABLE)
        printf("thread join\n");
    else
        printf("thread un known\n");

    /* 设置线程分离属性*/
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);

    while (1) {
        /* 在堆上申请内存，指定线程栈的起始地址和大小*/
        stackaddr = malloc(SIZE);
        if (stackaddr == NULL) {
            perror("malloc");
            exit(1);
        }

        stacksize = SIZE;
        pthread_attr_setstack(&attr, stackaddr, stacksize);
        err = pthread_create(&tid, &attr, th_fun, NULL);
        if (err != 0) {
            printf("%s\n", strerror(err));
            exit(1);
        }
        printf("%d\n", i++);
    }

    pthread_attr_destroy(&attr);
    
    return 0;
}

四、NPTL

查看当前pthread库版本 getconf GNU_LIBPTHREADED_VERSION

五、线程使用注意事项

1、主线程退出其他线程不退出，主线程应调用pthread_exit
2、避免僵尸线程。
      pthread_join
      pthread_detach
      pthread_create指定分离属性,
3、被join线程可能在join函数返回前就释放完自己的所有内存资源，所以不应当返回被回收线程栈中的值; malloc和mmap申请的内存可以被其他线程释放。
4、应避免在多线程模型中调用fork，除非马上 exec，子进程中只有调用fork 的线程存在，其他线程在子进程中均pthread_exit
5、信号的复杂语义很难和多线程共存，应避免在多线程引入信号机制。

TenSirFly
关注
专栏目录
进程&&线程&&IO复用技术
qq_43473072的博客
01-21 673
进程&&线程进程 进程 什么是进程? 进程的特性? 进程创建函数? 创建子进程的资源拷贝问题? 进程地址划分
Linux线程学习笔记
wantc的博客
07-14 147
线程相关学习：线程、互斥锁、条件
linux系统编程笔记——线程(1) 线程基本概念
qq_44807796的博客
02-18 132
线程
Linux基础——进程与线程知识点总结
祖国栋梁一的博客
08-15 209
Linux基础——进程与线程知识点总结
关于多线程栈空间的若干问题
寻亚楠的专栏
03-30 9450
1.一个进程应该有自己独立的进程空间。 应当说每个进程各自拥有其独立的地址空间.都是虚地址,在32位机上都是0-4G 2. 而创建了多线程，各个线程要求有自己独立的栈，这些独立的栈是怎么分布的呢？ 栈应当是一个动态地概念,只有在线程开始执行后,才为其分配栈资源.具体的分布是无法确定的.我觉得这就像 调用函数一样,当调用函数时,进程通过调整栈基址指针寄存器和栈顶指针寄存器,为函数
linux 线程
xiami
02-13 287
线程概念： 进程：有独立的 进程地址空间。 有独立的pcb。 分配资源最小单位 线程：有独立的 pcb。 没有独立的进程地址空间 执行最小单位 ps-Lf 进程id --》线程号 LWP -->CPU 执行的最小单位 线程共享资源： 1.文件描述符 2.每种信号的处理方式 3.当前工作目录 4....
（七）Linux系统编程之线程（中）
CarmenIsOK的博客
05-29 332
一、哲学家就餐模型
Linux/C++多线程编程学习笔记——线程同步、锁
mwz18959217316的博客
09-20 735
linux/C++线程同步机制，锁
Linux/C++多线程编程学习笔记——多线程基本操作
mwz18959217316的博客
08-30 401
C++/Linux多线程编程的基本操作
Linux系统编程学习笔记——进程
weixin_51215586的博客
10-30 532
进程相关概念 1.什么是程序，什么是进程 程序：一般是放在实体磁盘中，通过使用者的运行来触发，出发后会加载到内存中成为一个个体，这就是程序。 程序（program）：通常为二进制，放置在储存媒体中（如光盘、硬盘、软盘、磁带等），为实体文件的形态存在。 进程（process）：程序触发后，运行者的权限与属性、程序的程序码和所需数据等都会被加载到内存中，操作系统给予这个内存单元一个识别码（PID），可以说，进程就是一个运行中的程序。 2.如何查看系统中有哪些进程 a.使用ps指令查看，实际工作，配合
《UNIX 环境高级编程》学习笔记——UNIX 基础知识
weixin_45243288的博客
01-08 1348
UNIX环境高级编程——UNIX 基础知识引言UNIX 体系结构登录文件和目录输入和输出程序和进程出错处理用户标识信号时间值系统调用和库函数小结 引言 所有操作系统都为它们所允许的程序提供服务。 典型的服务包括：执行新程序、打开文件、读文件、分配存储区以及获得当前时间等。 UNIX 体系结构 可将操作系统定义为一种软件，它控制计算机硬件资源，提供程序运行环境。 通常将这种软件称为内核，因为它相对较小，而且位于环境的核心。 内核的接口被称为系统调用。 公用函数库构建在系统调用接口之上，应用程序既可使用公用函
Linux 编程 —— 多线程双 buffer 缓存引擎设计理念
最新发布
Aliven888的博客
05-15 669
在进行多线程编程时，我们总是会遇到多线程读写竞争的问题，为了解决这种多线程同时访问同一变量时出现竞争的问题，操作系统层面提供了锁、信号量、条件变量等几种线程同步机制。
Linux系统编程——线程函数（三）
sum_TW的博客
04-02 448
今天我们编写一个程序来实现线程有关的函数： 主要使用了平pthread_testcancelhan函数和pthread_cancel函数， #include #include #include #include void *tfn(void *arg) { int i; i = (int)arg; //强转。 if (i == 2) { pthr
Linux编程：线程终止、线程挂起（类似进程的wait）函数使用
quhongjuan12的博客
05-17 821
Linux编程：线程终止、线程挂起（类似进程的wait）函数使用 #include<stdlib.h> #include<stdio.h> #include<unistd.h> #include<pthread.h> typedef struct{ int a; int b; }exit_t; void *tfn(void *arg) { exit_t *ret; ret=malloc(sizeof(exit_t)); ret->a=100
48.Linux 线程 Thread（一）
m0_57908316的博客
11-08 4751
学习目标 ①了解线程的定义 ②掌握常用的线程操作 ③熟练通过线程属性设置线程状态 ④掌握线程同步的方法 从很多Linux的书籍我们都可以这样子描述进程（process）和线程（thread）的： 进程是资源管理的最小单位，线程是程序执行的最小单位。 线程的本质是一个进程内部的一个控制序列，它是进程里面的东西，一个进程可以拥有一个进程或者多个进程。 当进程执行fork()函数创建一个进程时，将创建出该进程的一份新副本。 这个新进程拥有自己的变量和自己的PID，它的执行几乎完全独立于父进程
Linux线程详解
热门推荐
小虾米编程
06-03 3万+
并行和并发的区别 1. 并发(concurrency)：在操作系统中，是指一个时间段中有几个程序都处于已启动运行到运行完毕之间，且这几个程序都是在同一个处理机上运行。其中两种并发关系分别是同步和互斥。（并发是指同一时刻只能有一条指令执行，但多个进程指令被快速轮换执行，使得在宏观上有多个进程被同时执行的效果--宏观上并行，针对单核处理器） 互斥：进程间相互排斥的使用临界资源的现象，就叫互斥。 ...
第七章_线程 : 线程的概念、创建与终止
matafeiyanll的博客
12-06 373
线程的概念、创建与终止 线程的概念 在Linux下，能够把线程看做是最小的运行单位(进程内部运用多线程完毕任务)。而进程是最小的分配资源单位(系统以进程为单位来创建，而没有创建一个线程来运行的说法)。实际上，不管是创建进程的fork，还是创建线程的pthread_create，底层的实现都是调用同一个内核函数clone。假设复制对方的地址空间。那就会产生一个”进程”。假设共享对方的地址空间，就产生一个”线程”。进程能够看作是仅仅有一个线程的进程。 由于。linux内核不区分进程和线程，仅仅在用户层面上区分。
互斥量(互斥锁)
月雲之霄的博客
10-26 1万+
一、互斥量mutex Linux提供一把互斥锁mutex(也称之为互斥量) 每个线程在对资源操作前都尝试先加锁，成功加锁才能操作，操作结束后解锁。 资源还是共享的，线程间也还是竞争的，但通过锁将资源的访问变为互斥操作，而后与时间有关的错误也不会在产生了。 如图所示： 但是应该注意：同一个时刻，只能有一个线程持有该锁。 当A线程对某个全局变量加锁访问，B在访问前尝试加锁，拿不到锁，B阻...
Unix/Linux内核编程：条件变量与线程同步
Unix/Linux操作系统，尤其是Unix的三大派生版本——System V、Berkley和Hybrid，以及后来的Linux，都广泛地支持多线程编程和条件变量。例如，AIX、Solaris、HP-UX、IRIX、FreeBSD、NetBSD、OpenBSD和MacOS X等操作...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值