Linux线程编程

已于 2024-09-17 19:46:33 修改
阅读量235 收藏
点赞数 1
分类专栏： # Linux系统/多线程/多进程/文件编程 文章标签： linux 线程 多线程 多进程
于 2023-11-19 21:39:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42136255/article/details/134495880
版权

Linux线程编程初步

一些历史背景

  1. Linux间接起源于Unix，而Linux诞生时并不存在 "线程"的概念。
  2. 在20世纪90年代线程才流行起来，POSIX Thread标准于 1995年确立。
  3. Unix中引入 Thread 之后，大量函数被重写，信号机制也变得复杂。
  4. 2005年之后，处理器生产厂商向超线程和多核架构靠拢。
  5. 超线程是英特尔开发出来的一项技术，使得单个处理器可以像两个逻辑处理器那样运行，这样单个处理器可以并行执行线程。

一些常见的概念

物理处理器：

安装在主机上的真实的处理器硬件。

逻辑处理器：

逻辑处理器与超线程技术相关。

        不支持超线程：逻辑处理器的数量等于核心数的数量

        支持超线程：  逻辑处理器的数量是处理器核心数的两倍

核心数：即多核处理器中的内核数量

        通过工艺手段将多个完整的 CPU 塞进一个处理器封装中(每一个 CPU 就是一个核)

线程与进程的关系

进程：

应用程序的一次加载执行(系统进行资源分配的基本单位)

线程：

进程中的程序执行流

  1. 一个进程中可以存在多个线程(至少存在一个线程)
  2. 每个线程执行不同的任务(多个线程可并行执行)
  3. 同一个进程中的多个线程共享进程的系统资源        

创建线程并不难，难的是创建的这些线程会和主线程一起往下执行。

初探线程编程模型

Linux多线程API函数

线程创建 ：pthread_create

NAME
       pthread_create - create a new thread

SYNOPSIS
       #include <pthread.h>

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

  1. pthread_t *thread ：变量的地址，用于返回线程标识
  2. attr ：线程的属性，可设置为NULL，即：使用默认属性
  3. start_routine ：线程入口函数
  4. arg ：线程入口函数参数

线程标识 ：pthread_self

pthread_t pthread_self(void); 获取当前线程的 ID 标识

线程等待 ：pthread_join

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

等待目标线程执行结束

main.c

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

void* thread_entry(void* arg)
{
    pthread_t id = pthread_self();
    int n = (long)arg;
    int i =0;

    while(i < n)
    {
        printf("id = %ld,i = %d\n",id,i);
        sleep(1);
        i++;
    }

    return NULL;
}

int main(int argc,char* argv[])
{
    pthread_t t1 = 0;
    pthread_t t2 = 0;
    long arg1 = 10;
    long arg2 = 5;

    pthread_create(&t1,NULL,thread_entry,(void*)arg1);
    pthread_create(&t2,NULL,thread_entry,(void*)arg2);

    printf("t1 = %ld\n",t1);
    printf("t2 = %ld\n",t2);

    pthread_join(t1,NULL);
    pthread_join(t2,NULL);


    return 0;
}

编译运行：

wj@ubuntu:~/DTThread/1-8$ gcc main.c -o main.out -lpthread
wj@ubuntu:~/DTThread/1-8$ ./main.out 
t1 = 140185317775104
t2 = 140185309382400
id = 140185317775104,i = 0
id = 140185309382400,i = 0
id = 140185309382400,i = 1
id = 140185317775104,i = 1
id = 140185317775104,i = 2
id = 140185309382400,i = 2
id = 140185317775104,i = 3
id = 140185309382400,i = 3
id = 140185317775104,i = 4
id = 140185309382400,i = 4
id = 140185317775104,i = 5
id = 140185317775104,i = 6
id = 140185317775104,i = 7
id = 140185317775104,i = 8
id = 140185317775104,i = 9

对比实验

实验一：性能对比

        相同功能的 多线程程序 vs 多进程程序的

        对比项：创建/销毁

实验二：内存共享

        多线程程序共享一段内存  ->  "全局变量"

        多进程程序共享一段内存 ->  "机制复杂"

多线程/多进程创建销毁10000次对比

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <math.h>
#include <errno.h>
#include <sched.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <pthread.h>

#define NSECS_PER_MSEC 1000000UL
#define NSECS_PER_SEC 1000000000UL
#define TEST_LOOPS 10000
#define DiffNS(begin,end) ((end.tv_sec - begin.tv_sec) * NSECS_PER_SEC \
                           + (end.tv_nsec - begin.tv_nsec))

void* thread_entry(void* arg)
{
    return NULL;
}

void thread_test()
{
    printf("thread test:\n");

    struct timespec begin = {0};
    struct timespec end = {0};
    pthread_t tid = 0;
    int i = 0;
    int diff = 0;

    clock_gettime(CLOCK_MONOTONIC,&begin);

    for(i=0;i<TEST_LOOPS;i++)
    {
        pthread_create(&tid,NULL,thread_entry,NULL);
        pthread_join(tid,NULL);
    }

    clock_gettime(CLOCK_MONOTONIC,&end);

    diff = DiffNS(begin,end) / NSECS_PER_MSEC;

    printf("result = %dms\n",diff);
}

void process_test()
{
    printf("process test: \n");

    struct timespec begin = {0};
    struct timespec end = {0};
    pid_t pid =0;
    int i=0;
    int diff =0;

    clock_gettime(CLOCK_MONOTONIC,&begin);

    for(i=0;i<TEST_LOOPS;i++)
    {
        pid = fork();

        if(pid) waitpid(pid,NULL,0);
        else return ;
    }

    clock_gettime(CLOCK_MONOTONIC,&end);

    diff = DiffNS(begin,end) / NSECS_PER_MSEC;

    printf("result = %dms\n",diff);

}

int main()
{
    thread_test();
    process_test();

    return 0;
}

编译运行：

wj@ubuntu:~/DTThread/1-7$ gcc test.c -o test.out -lpthread
wj@ubuntu:~/DTThread/1-7$ ./test.out 
thread test:
result = 652ms
process test: 
result = 1787ms
wj@ubuntu:~/DTThread/1-7$

可以看到多进程创建/销毁 更加耗时。

多线程/多进程创建销毁20000次对比

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <math.h>
#include <errno.h>
#include <sched.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <pthread.h>

#define NSECS_PER_MSEC 1000000UL
#define NSECS_PER_SEC 1000000000UL
#define TEST_LOOPS 20000
#define DiffNS(begin,end) ((end.tv_sec - begin.tv_sec) * NSECS_PER_SEC \
                           + (end.tv_nsec - begin.tv_nsec))

void* thread_entry(void* arg)
{
    return NULL;
}

void thread_test()
{
    printf("thread test:\n");

    struct timespec begin = {0};
    struct timespec end = {0};
    pthread_t tid = 0;
    int i = 0;
    int diff = 0;

    clock_gettime(CLOCK_MONOTONIC,&begin);

    for(i=0;i<TEST_LOOPS;i++)
    {
        pthread_create(&tid,NULL,thread_entry,NULL);
        pthread_join(tid,NULL);
    }

    clock_gettime(CLOCK_MONOTONIC,&end);

    diff = DiffNS(begin,end) / NSECS_PER_MSEC;

    printf("result = %dms\n",diff);
}

void process_test()
{
    printf("process test: \n");

    struct timespec begin = {0};
    struct timespec end = {0};
    pid_t pid =0;
    int i=0;
    int diff =0;

    clock_gettime(CLOCK_MONOTONIC,&begin);

    for(i=0;i<TEST_LOOPS;i++)
    {
        pid = fork();

        if(pid) waitpid(pid,NULL,0);
        else return ;
    }

    clock_gettime(CLOCK_MONOTONIC,&end);

    diff = DiffNS(begin,end) / NSECS_PER_MSEC;

    printf("result = %dms\n",diff);

}

int main()
{
    thread_test();
    process_test();

    return 0;
}

编译运行：

wj@ubuntu:~/DTThread/1-7$ gcc test.c -o test.out -lpthread
wj@ubuntu:~/DTThread/1-7$ ./test.out 
thread test:
result = 1260ms
process test: 
result = 3511ms

可以看到多进程创建/销毁更加耗时。

多线程内存共享

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <math.h>
#include <errno.h>
#include <sched.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <pthread.h>

void* thread_entry(void* arg)
{
    printf("pid = %d,ppid = %d,pgid = %d\n",getpid(),getppid(),getpgrp());

    char* shmaddr = arg;

    strcpy(shmaddr,"D.T.Software");

    return NULL;
}

int main()
{
    char* mem = malloc(128);
    pthread_t child = 0;

    printf("mem = %p\n",mem);

    if(mem == NULL)
    {
        printf("malloc error\n");
        exit(1);
    }

    int r = pthread_create(&child,NULL,thread_entry,mem);
    if(r == 0)
    {
        printf("pid = %d,ppid = %d,pgid = %d\n",getpid(),getppid(),getpgrp());

        char* shmaddr = mem;

        pthread_join(child,NULL);

        printf("%s\n",shmaddr);
    }
    else
    {
        printf("create thread error...\n");
    }

    free(mem);


    return 0;
}

编译运行：

wj@ubuntu:~/DTThread/1-7$ gcc shm-thread.c -o shm-thread.out -lpthread
wj@ubuntu:~/DTThread/1-7$ ./shm-thread.out 
mem = 0x55ffc6ee82a0
pid = 76297,ppid = 4384,pgid = 76297
pid = 76297,ppid = 4384,pgid = 76297
D.T.Software

多进程内存共享

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <math.h>
#include <errno.h>
#include <sched.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/wait.h>
#include <sys/shm.h>

#define PATH_NAME "."
#define PROJ_ID 88

int main()
{
    key_t k = ftok(PATH_NAME,PROJ_ID);
    int shmid = shmget(k,128,IPC_CREAT | S_IRWXU);

    printf("shmid = %d\n",shmid);

    if(shmid == -1)
    {
        printf("shmget error\n");
        exit(1);
    }

    int pid = fork();

    if(pid)
    {
        printf("pid = %d,ppid = %d,pgid = %d\n",getpid(),getppid(),getpgrp());

        char* shmaddr = shmat(shmid,NULL,0);

        waitpid(pid,NULL,0);

        printf("%s\n",shmaddr);
    }
    else if(pid == 0)
    {
        printf("pid = %d,ppid = %d,pgid = %d\n",getpid(),getppid(),getpgrp());

        char* shmaddr = shmat(shmid,NULL,0);

        strcpy(shmaddr,"D.T.SoftWare");

        exit(0);
    }
    else
    {
        printf("fork error...\n");
    }

    shmctl(shmid,IPC_RMID,NULL);


    return 0;
}

编译运行：

wj@ubuntu:~/DTThread/1-7$ ./shm-proc.out 
shmid = 65585
pid = 76855,ppid = 4384,pgid = 76855
pid = 76856,ppid = 76855,pgid = 76855
D.T.SoftWare

通过以上输出，可以看到是两个不同的进程，在共享同一块内存。

深入研究线程原理

Linux中线程本质

  1. 线程是后引入操作系统的概念。进程是最先引入操作系统的概念，然后是引入了线程，然后又引入了协程。从进程 -> 线程 -> 协程 来看，执行单元要越来越轻量化。
  2. 线程接口由 Native POSIX Thread Library提供，即：NPTL库函数。
  3. 线程被称为轻量级进程(Light Weighted Process)
  4. 每一个线程在内核中都对应一个调度实体，拥独立的结构体 (task_struct)
  5.  内核设计：一个进程对应内核中的一个结构体(task_struct)，对应一个进程标识(PID)
  6. 引入线程：线程是内核的调度实体，在内核中必然对应一个结构体。 
  7. 内核角度：对于一个线程来说，它与一个进程的区别在哪里？就是资源不一样。

Linux中的线程本质：

用户模式：一个进程中存在多个线程

内核模式：每个线程是一个独立的调度实体。

问题：内核怎么知道某个调度实体属于哪一个进程？

另外一种视角

  1. 拥有多线程的进程，又被称为线程组(谁是线程组长?，主线程是线程组长)
  2. 在内核数据结构 task_struct 中存在 pid 和 tgid :
    1. pid_t pid -> 线程标识符 (Thread ID)
    2. pid_t tgid -> 线程组标识符 (Thread Group ID)，用来存储用户模式下的进程标识
    3. 对于主线程来说，pid 等于 tgid

用户模式系统调用task_struct
线程标识符pid_t gettid(void);pid_t pid;
进程标识符pid_t getpid(void);pid_t tgid;

进程创建后默认拥有一个线程，即：主线程(默认执行流)

主线程的LWP标识符与进程标识符相同，即：主线程为线程组长(pid等于tgid)

其他子线程创建后隶属于当前进程：

        子线程的LWP标识符各不相同，且与进程标识符不同，但tgid相同

        子线程调用getpid()的结果相同(why?)

实验demo

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <pthread.h>
#include <sys/syscall.h>

//从内核的角度，拿到线程id，也就是内核 task_struct结构体中的 pid
pid_t gettid()
{
    return syscall(SYS_gettid);
}

void* thread_enrty(void* arg)
{
    pid_t pid = getpid(); //和 main函数中，主线程 pid 一样
    pid_t tid = gettid(); //和 mian函数中，主线程 的 tid 不一样
    pthread_t self = pthread_self();

    printf("thread:pid = %d\n",pid);
    printf("thread:tid = %d\n",tid);
    printf("thread:self = %ld\n",self);

    return NULL;
}

int main(int argc,char* argv[])
{
    pthread_t t=0;
    pthread_t self = pthread_self();
    pid_t pid = getpid();
    pid_t tid = gettid(); //主线程的 pid 等于 tgid

    printf("main:pid = %d\n",pid);
    printf("main:tid = %d\n",tid);
    printf("main:self = %ld\n",self);

    pthread_create(&t,NULL,thread_enrty,NULL);

    printf("main:t = %ld\n",t);

    pthread_join(t,NULL);

    return 0;
}

编译输出：

wj@wj:~/linux/1-7$ gcc test1.c -o test1.out -lpthread
wj@wj:~/linux/1-7$ ./test1.out 
main:pid = 10495
main:tid = 10495
main:self = 132228026910528
main:t = 132228021487296
thread:pid = 10495
thread:tid = 10496
thread:self = 132228021487296
wj@wj:~/linux/1-7$

思考问题

对于一个线程来说， pid_t tid = gettid();  pthread_t self = pthread_self(); 这两个函数都能够标识一个线程，那么他们之间的区别是什么呢？

线程 pid_t 是全局范围内对调度实体的唯一标识，是给内核层面使用的。

线程 pthread_t 是应用程序中对线程的局部描述，是用户层面使用的。

值得思考的问题

1.多线程之间是否有 “父子关系”？

无。进程中只有主线程和子线程，线程之间没有“父子关系”。

2.主线程如果先于子线程结束会发生什么？

Linux中主线程如果执行结束，则进程结束。进程结束则进程资源被释放，子线程被迫结束。

3.使用kill命令是否能够“杀死”制定线程？

默认情况下，kill是用来给进程发信号的(SIGTREM信号)，而信号的目标是进程，是用来杀死进程的。

因此，kill任意子线程的 pid_t 将导致整个进程结束。

4.pthread_t 究竟是什么数据类型？

pthread_t是 POSIX Thread中的接口，具体定义与系统相关。

通常情况下，pthread_t的具体定义是一个无符号整型值。

        Linux中 pthread_t的定义是64位整型(保存地址值)

        其他系统中，pthread_t直接映射为 Task ID值

        对于一些特殊的系统，pthread_t是一个结构体。

repinkply
关注
专栏目录
Linux——多线程编程
weixin_51526796的博客
03-29 801
•。
linux多线程编程
chenxihanhui的博客
08-12 224
linux多线程编程 这个帖子是一边改代码一边写的，可能会有点乱，有空再好好整理一下 linux多线程编程使用的接口主要包含在头文件<pthread.h>中 常用接口 创建线程 多线程入门 //多线程 #include <stdio.h> #include <pthread.h> #include <unistd.h> void* print1(){ while(1){ sleep(1); printf("This is thread1\n");
【Linux线程】Linux线程编程基础：概念、创建与管理
最新发布
EterNity_TiMe_的计算机学习之路
10-16 1947
在当今的软件开发领域，多线程编程已经成为了一种不可或缺的技术。特别是在Linux操作系统环境下，多线程编程更是被广泛地应用于各种高性能、高并发的应用场景中。然而，多线程编程也是一项极具挑战性的任务，它要求开发者具备扎实的编程基础，对并发控制、资源管理等有深入的理解
Linux多线程编程
长期更新自学笔记
01-06 2103
线程同步： 多线程环境中，无论调度顺序怎么样，都能得到我们想要的结果 同步的方法： 信号量、互斥锁、条件变量、读写锁 互斥锁只能用于互斥型场景，它的作用等同于二值（0/1）信号量的作用 pthread_create：创建并启动线程 pthread_exit：退出线程 #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <string.h> #include <pthre
Linux 多线程编程
weixin_51685146的博客
03-02 238
Linux 多线程的概念 1.线程的创建 #include <pthread.h> int pthread_create(pthread_t *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void *), void *restrict arg); // 返回：若成功返回0，否则返回错误编号 //pthread_t *restrict tidp：长整型的指针，当pthread_create成功返回时，
linux线程编程-详解
08-20
线程编程函数是实现线程编程的关键， Linux 提供了多种线程编程函数，其中 pthread_create 和 pthread_join 是两种基本的线程编程函数。 pthread_create 函数是创建新的线程的函数，函数原型为： `int pthread_...
Linux线程编程之信号处理.rar
11-16
本资料"Linux线程编程之信号处理"深入探讨了这两个主题在Linux环境下的应用。 首先，我们来了解Linux线程的基本概念。线程是操作系统分配处理器时间的基本单元，它共享同一进程的内存空间和其他资源。在Linux中，...
Linux线程编程之生产者消费者问题
12-14
Linux线程编程中的生产者消费者问题是多线程编程中一个经典的同步问题，它涉及到线程间的协作和资源的共享。生产者线程负责生成数据并放入队列，而消费者线程则从队列中取出数据进行处理。在这个过程中，如何保证...
操作系统-4.4-Linux线程编程1
08-03
操作系统-4.4-Linux线程编程1 Linux线程编程是操作系统中的一种重要概念，它允许开发者在单个进程中创建多个线程，从而提高系统的并发性和效率。在本节中，我们将详细介绍Linux线程编程的基本概念、API和示例。 一...
linux 线程编程
zhuky的专栏
12-16 7038
本章介绍 POSIX 线程的基本线程编程例程。本章介绍缺省线程（即，具有缺省属性值的线程），这是多线程编程中最常用的线程。本章还介绍如何创建和使用具有非缺省属性的线程。本章介绍的 POSIX 例程具有与最初的 Solaris 多线程库相似的编程接口。线程库下面简要论述了特定任务及其相关手册页。 创建缺省线程如果未指定属性对象，则该对象为 NULL，系统会创建具有以下属性
Day 28 pthread 线程 pthread_create, pthread_self, pthread_exit pthread_cancel, lbb a.out,
nihap123456的博客
08-17 174
1.pthread 线程 优点： 比多进程节省资源，可以共享变量。 概念：线程是轻量级进程，一般是一个进程中的多个任务。 进程是系统中最小的资源分配单位. 线程是系统中最小的执行单位。 线程的启动要比进程快。 当一个进程运行后进程中会有一个主线程，如果再创建线程也只能是子线程。 特征： 1、共享资源 2、效率高 30% 3、三方库： pthread clone posix 3.1 编...
Linux系统编程-线程
weixin_47609911的博客
06-19 445
进程与线程 典型的UNIX/Linux进程可以看成只有一个控制线程：一个进程在同一时刻只做一件事情。 有了多个控制线程后，在程序设计时可以把进程设计成在同一时刻做不止一件事，每个线程各自处理独立的任务。 进程是程序执行时的一个实例，是担当分配系统资源（CPU时间、内存等）的基本单位。 在面向线程设计的系统中，进程本身不是基本运行单位，而是线程的容器。 程序本身只是指令、数据及其组织形式的描述，进程才是程序（那些指令和数据）的真正运行实例。 线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是
Linux系统编程——线程
weixin_42149066的博客
10-08 166
Linux系统编程——线程
Linux高级编程——线程
m0_71703182的博客
06-28 1192
===》 子线程的结束不会影响主线程的运行。====》主线程结束任意生成的子线程都会结束。功能：请求结束一个线程 (在主线程种调用 写入某个线程id号,可以关闭该线程)参数：thread 请求结束一个线程tid(想要关闭的线程id号)返回值：pthread_exit(0) ===>pthread_exit(9);1、线程的回收机制 ====》不同与进程没有孤儿线程和僵尸线程。要回收的子线程返回值/状态。==》ptread_exit(值);
Linux 线程编程
武溪嵌人
11-25 710
inux--线程编程 进程 　　系统中程序执行和资源分配的基本单位 　　每个进程有自己的数据段、代码段和堆栈段 　　在进行切换时需要有比较复杂的上下文切换   线程 　　减少处理机的空转时间，支持多处理器以及减少上下文切换开销, 比创建进程小很多 　　进程内独立的一条运行路线 　　处理器调度的最小单元，也称为轻量级进程 可
多线程编程之：Linux线程编程
08-02
Linux 多线程编程之线程编程 Linux 多线程编程是指在 Linux 操作系统中使用多线程技术来实现并发编程。线程是一种轻量级的进程，它可以共享同一个进程的资源和地址空间。在 Linux 中，pthread 线程库是一套通用的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

repinkply

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

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

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

打赏作者

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

抵扣说明：

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

余额充值