linux系统编程--线程

安装线程man page，命令：sudo apt-get install manpages-posix-dev

线程概念

什么是线程

LWP：light weight process 轻量级的进程，本质仍是进程(在Linux环境下)

         进程：独立地址空间，拥有PCB

         线程：也有PCB，但没有独立的地址空间(共享)

         区别：在于是否共享地址空间。         独居(进程)；合租(线程)。

         Linux下：           线程：最小的执行单位

                                    进程：最小分配资源单位，可看成是只有一个线程的进程。

linux系统编程--线程

在程序中创建线程，可以提高效率，进程内线程越多，争夺到CPU的概率就越大，执行代码的概率就越大（有一个度）。CPU将线程和进程等同处理

linux系统编程--线程

Linux内核线程实现原理

类Unix系统中，早期是没有“线程”概念的，80年代才引入，借助进程机制实现出了线程的概念。因此在这类系统中，进程和线程关系密切。

1. 轻量级进程(light-weight process)，也有PCB，创建线程使用的底层函数和进程一样，都是clone

2. 从内核里看进程和线程是一样的，都有各自不同的PCB，但是PCB中指向内存资源的三级页表是相同的

3. 进程可以蜕变成线程

4. 线程可看做寄存器和栈的集合

5. 在linux下，线程最是小的执行单位；进程是最小的分配资源单位

察看LWP号：ps –Lf pid 查看指定线程的lwp号。ps -eLf

UID         PID   PPID    LWP  C NLWP STIME TTY      STAT   TIME CMD
gec        6699   1784   6699 12   54 06:12 ?        Sl     0:03 /usr/lib/firefox/firefox
gec        6699   1784   6706  0   54 06:12 ?        Sl     0:00 /usr/lib/firefox/firefox
gec        6699   1784   6707  0   54 06:12 ?        Sl     0:00 /usr/lib/firefox/firefox

 

linux系统编程--线程 

三级映射：进程PCB --> 页目录(可看成数组，首地址位于PCB中) --> 页表 --> 物理页面 --> 内存单元

linux系统编程--线程

参考：《Linux内核源代码情景分析》 ----毛德操

对于进程来说，相同的地址(同一个虚拟地址)在不同的进程中，反复使用而不冲突。原因是他们虽虚拟址一样，但，页目录、页表、物理页面各不相同。

相同的虚拟址，映射到不同的物理页面内存单元，最终访问不同的物理页面。

但！线程不同！两个线程具有各自独立的PCB，但共享同一个页目录，也就共享同一个页表和物理页面。所以两个PCB共享一个地址空间。

         实际上，无论是创建进程的fork，还是创建线程的pthread_create，底层实现都是调用同一个内核函数clone。

         如果复制对方的地址空间，那么就产出一个“进程”；如果共享对方的地址空间，就产生一个“线程”。

         因此：Linux内核是不区分进程和线程的。只在用户层面上进行区分。所以，线程所有操作函数 pthread_* 是库函数，而非系统调用。

 

线程共享资源

http://www.cnblogs.com/youxin/p/4102883.html

         1.文件描述符表

         2.每种信号的处理方式

 

尽量不要在一个程序中，即使用线程又使用信号，这会比较复杂，不好调试。

线程共享信号处理方式，所以当一个信号来的时候，到底哪一个线程去处理（谁先抢到谁处理）。或者可以单独设置mask阻塞信号（信号屏蔽字）

linux系统编程--线程

         3.当前工作目录

         4.用户ID和组ID

         5.内存地址空间 (.text/.data/.bss/heap/共享库) 。每个线程是唯一的执行单位，因此栈不能共享

线程非共享资源

         1.线程id

         2.处理器现场和栈指针(内核栈)

         3.独立的栈空间(用户空间栈)

         4.errno变量

         5.信号屏蔽字

         6.调度优先级

线程优、缺点

         优点：     1. 提高程序并发性        2. 开销小        3. 数据通信、共享数据方便

         缺点：     1. 库函数，不稳定        2. 调试、编写困难、gdb不支持          3. 对信号支持不好

         优点相对突出，缺点均不是硬伤。Linux下由于实现方法导致进程、线程差别不是很大。

线程控制原语

pthread_self函数

获取线程ID。其作用对应进程中 getpid() 函数。

         pthread_t pthread_self(void); 返回值：成功：0；       失败：无！

         线程ID：pthread_t类型，本质：在Linux下为无符号整数(%lu)，其他系统中可能是结构体实现

         线程ID是进程内部，识别标志。(两个进程间，线程ID允许相同)

         注意：不应使用全局变量 pthread_t tid，在子线程中通过pthread_create传出参数来获取线程ID，而应使用pthread_self。

pthread_create函数

创建一个新线程。其作用，对应进程中fork() 函数。

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

         返回值：成功：0；       失败：错误号         -----Linux环境下，所有线程特点，失败均直接返回错误号。

参数：    

         pthread_t：当前Linux中可理解为：typedef unsigned long int pthread_t。

　　  1. 传出参数，保存系统为我们分配好的线程ID

         2. 通常传NULL，表示使用线程默认属性。若想使用具体属性也可以修改该参数。

         3. 函数指针，指向线程主函数(线程体)，该函数运行结束，则线程结束。

         4. 线程主函数执行期间所使用的参数（给回调函数传参）。

在一个线程中调用pthread_create()创建新的线程后，当前线程从pthread_create()返回继续往下执行，而新的线程所执行的代码由我们传给pthread_create的函数指针start_routine决定。start_routine函数接收一个参数，是通过pthread_create的arg参数传递给它的，该参数的类型为void *，这个指针按什么类型解释由调用者自己定义。start_routine的返回值类型也是void *，这个指针的含义同样由调用者自己定义。start_routine返回时，这个线程就退出了，其它线程可以调用pthread_join得到start_routine的返回值，类似于父进程调用wait(2)得到子进程的退出状态，稍后详细介绍pthread_join。

pthread_create成功返回后，新创建的线程的id被填写到thread参数所指向的内存单元。我们知道进程id的类型是pid_t，每个进程的id在整个系统中是唯一的，调用getpid(2)可以获得当前进程的id，是一个正整数值。线程id的类型是thread_t，它只在当前进程中保证是唯一的，在不同的系统中thread_t这个类型有不同的实现，它可能是一个整数值，也可能是一个结构体，也可能是一个地址，所以不能简单地当成整数用printf打印，调用pthread_self(3)可以获得当前线程的id。

attr参数表示线程属性，本节不深入讨论线程属性，所有代码例子都传NULL给attr参数，表示线程属性取缺省值，感兴趣的读者可以参考APUE。

【练习】：创建一个新线程，打印线程ID。注意：链接线程库 -lpthread  【pthrd_crt.c】

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

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

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

    int ret = pthread_create(&tid, NULL, tfn, NULL);
    if (ret != 0) {
        //printf("pthread_create erro: %s\n", strerror(ret));
        fprintf(stderr, "pthread_create erro: %s\n", strerror(ret));
        exit(1);
    }
    sleep(1);

    return 0;
}
pid = 125776,pthread = 2094708480
pid = 125776,pthread = 2086381312

 

由于pthread_create的错误码不保存在errno中，因此不能直接用perror(3)打印错误信息，可以先用strerror(3)把错误码转换成错误信息再打印。

如果任意一个线程调用了exit或_exit，则整个进程的所有线程都终止，由于从main函数return也相当于调用exit，为了防止新创建的线程还没有得到执行就终止，

我们在main函数return之前延时1秒，这只是一种权宜之计，即使主线程等待1秒，内核也不一定会调度新创建的线程执行，下一节我们会看到更好的办法。

【练习】：循环创建多个线程，每个线程打印自己是第几个被创建的线程。(类似于进程循环创建子进程)   【more_pthrd.c】

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

void *tfn(void *arg)
{
    int i;

    i = (int)arg;
    sleep(i);     //通过i来区别每个线程
    printf("I'm %dth thread, Thread_ID = %lu\n", i+1, pthread_self());

    return NULL;
}

int main(int argc, char *argv[])
{
    int n = 5, i;
    pthread_t tid;

    if (argc == 2)
        n = atoi(argv[1]);

    for (i = 0; i < n; i++) {
        pthread_create(&tid, NULL, tfn, (void *)i);
        //将i转换为指针，在tfn中再强转回整形。
    }
    sleep(n);
    printf("I am main, and I am not a process, I'm a thread!\n" 
            "main_thread_ID = %lu\n", pthread_self());

    pthread_exit(NULL);
}
I'm 1th thread, Thread_ID = 140579885291264
I'm 2th thread, Thread_ID = 140579876898560
I'm 3th thread, Thread_ID = 140579868505856
I'm 4th thread, Thread_ID = 140579860113152
I'm 5th thread, Thread_ID = 140579851720448
I am main, and I am not a process, I'm a thread!
main_thread_ID = 140579893618432

 

拓展思考：将pthread_create函数参4修改为(void *)&i, 将线程主函数内改为 i=*((int *)arg) 是否可以。  i++会出现错乱           

linux系统编程--线程

线程与共享

【牢记】：线程默认共享数据段、代码段等地址空间，常用的是全局变量。而进程不共享全局变量，只能借助mmap。

【练习】：设计程序，验证线程之间共享全局数据。【glb_var_pthrd.c】

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

int var = 100;

void *tfn(void *arg)
{
    var = 200;
    printf("thread\n");

    return NULL;
}

int main(void)
{
    printf("At first var = %d\n", var);

    pthread_t tid;
    pthread_create(&tid, NULL, tfn, NULL);
    sleep(1);

    printf("after pthread_create, var = %d\n", var);

    return 0;
}

 

At first var = 100
thread
after pthread_create, var = 200

 

pthread_exit函数

将单个线程退出

         void pthread_exit(void *retval);      参数：retval表示线程退出状态，通常传NULL

思考：使用exit将指定线程退出，可以吗？【pthrd_exit.c】

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

void *tfn(void *arg)
{
    int i;

    i = (int)arg;//强转。
    if (i == 2)
        pthread_exit(NULL);

    sleep(i);     //通过i来区别每个线程
    printf("I'm %dth thread, Thread_ID = %lu\n", i+1, pthread_self());

    return NULL;
}

int main(int argc, char *argv[])
{
    int n = 5, i;
    pthread_t tid;

    if (argc == 2)
        n = atoi(argv[1]);

    for (i = 0; i < n; i++) {
        pthread_create(&tid, NULL, tfn, (void *)i);
        //将i转换为指针，在tfn中再强转回整形。
    }
    sleep(n);
    printf("I am main, I'm a thread!\n" 
            "main_thread_ID = %lu\n", pthread_self());

    return 0;
}

 

         结论：线程中，禁止使用exit函数，会导致进程内所有线程全部退出。

         在不添加sleep控制输出顺序的情况下。pthread_create在循环中，几乎瞬间创建5个线程，但只有第1个线程有机会输出（或者第2个也有，也可能没有，取决于内核调度）如果第3个线程执行了exit，将整个进程退出了，所以全部线程退出了。

         所以，多线程环境中，应尽量少用，或者不使用exit函数，取而代之使用pthread_exit函数，将单个线程退出。任何线程里exit导致进程退出，其他线程未工作结束，主控线程退出时不能return或exit。

　　另注意，pthread_exit或者return返回的指针所指向的内存单元必须是全局的或者是用malloc分配的，不能在线程函数的栈上分配，因为当其它线程得到这个返回指针时线程函数已经退出了。

【练习】：编写多线程程序，总结exit、return、pthread_exit各自退出效果。

         return：返回到调用者那里去。

         pthread_exit()：将调用该函数的线程退出                   

         exit: 将进程退出。

pthread_join函数

阻塞等待线程退出，获取线程退出状态              其作用，对应进程中 waitpid() 函数。

 int pthread_join(pthread_t thread, void **retval); 成功：0；失败：错误号

参数：thread：线程ID （【注意】：不是指针）；retval：存储线程结束状态。

对比记忆：

                   进程中：main返回值、exit参数-->int；等待子进程结束 wait 函数参数-->int *

                   线程中：线程主函数返回值、pthread_exit-->void *；等待线程结束 pthread_join 函数参数-->void **

【练习】：参数 retval 非空用法。【pthrd_exit_join.c】

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

typedef struct{
    int a;
    int b;
} exit_t;

void *tfn(void *arg)
{
    exit_t *ret;
    ret = malloc(sizeof(exit_t)); 

    ret->a = 100;
    ret->b = 300;
    pthread_exit((void *)ret);

    return NULL; //should not be here.
}

int main(void)
{
    pthread_t tid;
    exit_t *retval;

    pthread_create(&tid, NULL, tfn, NULL);
    /*调用pthread_join可以获取线程的退出状态*/
    pthread_join(tid, (void **)&retval);
    printf("a = %d, b = %d \n", retval->a, retval->b);

    return 0;
}

 

调用该函数的线程将挂起等待，直到id为thread的线程终止。thread线程以不同的方法终止，通过pthread_join得到的终止状态是不同的，总结如下：

1.       如果thread线程通过return返回，retval所指向的单元里存放的是thread线程函数的返回值。

2.       如果thread线程被别的线程调用pthread_cancel异常终止掉，retval所指向的单元里存放的是常数PTHREAD_CANCELED。

3.       如果thread线程是自己调用pthread_exit终止的，retval所指向的单元存放的是传给pthread_exit的参数。

4.       如果对thread线程的终止状态不感兴趣，可以传NULL给retval参数。

 

【练习】：使用pthread_join函数将循环创建的多个子线程回收。【pthrd_loop_join.c】

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

int var = 100;

void *tfn(void *arg)
{
    int i;
    i = (int)arg;
    
    sleep(i);
    if (i == 1) {    //i = 0  100  333  333  777  777  
        var = 333;
        printf("var = %d\n", var);
        pthread_exit((void *)var);

    } else  if (i == 3) {
        var = 777;
        printf("I'm %dth pthread, pthread_id = %lu\n var = %d\n", i+1, pthread_self(), var);
        pthread_exit((void *)var);

    } else  {

        printf("I'm %dth pthread, pthread_id = %lu\n var = %d\n", i+1, pthread_self(), var);
        pthread_exit((void *)var);
    }

    return NULL;
}

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

    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("-------%d 's ret = %d\n", i, (int)ret[i]);
    }
    printf("I'm main pthread tid = %lu\t var = %d\n", pthread_self(), var);

    pthread_exit(NULL);
}
View Code

相关文章：

猜你喜欢
相关资源
相似解决方案
热门标签
Java Python linux javascript Mysql C# Docker 算法 前端 SpringBoot Redis Vue spring 设计模式 .net core .net kubernetes c++ 数据库 数据结构 大数据 js 机器学习 微服务 Android Go 程序员 面试 JVM ASP.net core 云原生 人工智能 后端 PHP git CSS golang k8s Nginx Django mybatis 深度学习 多线程 React 架构 devops 爬虫 云计算 Spring Boot LeetCode