[Linux 高并发服务器]线程

Posted 鱼竿钓鱼干

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了[Linux 高并发服务器]线程相关的知识，希望对你有一定的参考价值。

[Linux 高并发服务器]线程

文章概述

本文为牛客网C++项目课:Linux高并发服务器的个人笔记，记录了线程相关的知识点

作者信息

NEFU 2020级 zsl
ID：fishingrod/鱼竿钓鱼干
Email：851892190@qq.com
欢迎各位引用此博客，引用时在显眼位置放置原文链接和作者基本信息

参考资料

感谢前辈们留下的优秀资料，从中学到很多，冒昧引用，如有冒犯可以私信或者在评论区下方指出

标题作者引用处
牛客网C++项目课:Linux高并发服务器牛客网贯穿全文，以此为基础
什么是线程？什么是进程？为什么要有线程？有什么关系与区别？ConstXiong线程与进程的区别，补充
linux线程控制&线程分离狼行线程分离补充
linux线程基础----线程属性FREMONT线程属性补充
线程同步kugle线程同步补充
进程、线程、锁的概念谓之小一解决死锁的思路

正文部分

线程的概念

来自牛客课程PPT

  1. 线程（thread）是允许应用程序并发执行多个任务的一种机制。一个进程可以包含多个线程。同一个程序中的所有线程均会独立执行相同程序，且共享同一份全局内存区域，其中包括初始化数据段、未初始化数据段，以及堆内存段。（传统意义上的 UNIX 进程只是多线程程序的一个特例，该进程只包含一个线程）
  2. 进程是 CPU 分配资源的最小单位，线程是操作系统调度执行的最小单位。
  3. 线程是轻量级的进程（LWP：Light Weight Process），在 Linux 环境下线程的本质仍是进程。

查看指定进程的 LWP 号：ps –Lf pid

打开firefox浏览器使用ps指定查看其PID，然后使用ps -Lf pid来查看其中的线程，可以发现他们同属于一个进程（PID相同）。实际上很多应用都是由多个线程组成的。

线程和进程区别

  1. 进程间的信息难以共享。由于除去只读代码段外，父子进程并未共享内存，因此必须采用一些进程间通信方式，在进程间进行信息交换。
  2. 调用 fork() 来创建进程的代价相对较高，即便利用写时复制技术，仍然需要复制诸如内存页表和文件描述符表之类的多种进程属性，这意味着 fork() 调用在时间上的开销依然不菲。
  3. 线程之间能够方便、快速地共享信息。只需将数据复制到共享（全局或堆）变量中即可。
  4. 创建线程比创建进程通常要快 10 倍甚至更多。线程间是共享虚拟地址空间的，无需采用写时复制来复制内存，也无需复制页表。

补充资料： 什么是线程？什么是进程？为什么要有线程？有什么关系与区别？
强烈推荐看看

虚拟地址空间视角

该图在牛客PPT基础上修改

多线程共享虚拟地址空间，其中栈空间和.text（代码）被每个线程瓜分

由于共享了虚拟地址空间，所以很多信息与资源也是共享的

  1. 进程 ID 和父进程 ID
  2. 进程组 ID 和会话 ID
  3. 用户 ID 和 用户组 ID
  4. 文件描述符表
  5. 信号处置
  6. 文件系统的相关信息：文件权限掩码（umask）、当前工作目录
  7. 虚拟地址空间（除栈、.text）

当然每个线程也有相对自己独立的资源

  1. 线程 ID
  2. 信号掩码
  3. 线程特有数据
  4. error 变量
  5. 实时调度策略和优先级
  6. 栈，本地变量和函数的调用链接信息

线程的相关操作

由于线程库不是标准库，因此在编译的时候需要进行链接

gcc pthread.c -o create -pthread

创建线程

/*
    一般情况下,main函数所在的线程我们称之为主线程（main线程），其余创建的线程
    称之为子线程。
    程序中默认只有一个进程，fork()函数调用，2进行
    程序中默认只有一个线程，pthread_create()函数调用，2个线程。

    #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
            失败：返回错误号。这个错误号和之前errno不太一样。
            获取错误号的信息：  char * strerror(int errnum);

*/
#include <stdio.h>
#include <pthread.h>
#include <string.h>
#include <unistd.h>

void * callback(void * arg) {
    printf("child thread...\\n");
    printf("arg value: %d\\n", *(int *)arg);
    return NULL;
}

int main() {

    pthread_t tid;

    int num = 10;

    // 创建一个子线程
    int ret = pthread_create(&tid, NULL, callback, (void *)&num);

    if(ret != 0) {
        char * errstr = strerror(ret);
        printf("error : %s\\n", errstr);
    } 

    for(int i = 0; i < 5; i++) {
        printf("%d\\n", i);
    }

    sleep(1);

    return 0;   // exit(0);
}

终止线程

/*

    #include <pthread.h>
    void pthread_exit(void *retval);
        功能：终止一个线程，在哪个线程中调用，就表示终止哪个线程
        参数：
            retval:需要传递一个指针，作为一个返回值，可以在pthread_join()中获取到。

    pthread_t pthread_self(void);
        功能：获取当前的线程的线程ID

    int pthread_equal(pthread_t t1, pthread_t t2);
        功能：比较两个线程ID是否相等
        不同的操作系统，pthread_t类型的实现不一样，有的是无符号的长整型，有的
        是使用结构体去实现的。
*/
#include <stdio.h>
#include <pthread.h>
#include <string.h>

void * callback(void * arg) {
    printf("child thread id : %ld\\n", pthread_self());
    return NULL;    // pthread_exit(NULL);
} 

int main() {

    // 创建一个子线程
    pthread_t tid;
    int ret = pthread_create(&tid, NULL, callback, NULL);

    if(ret != 0) {
        char * errstr = strerror(ret);
        printf("error : %s\\n", errstr);
    }

    // 主线程
    for(int i = 0; i < 5; i++) {
        printf("%d\\n", i);
    }

    printf("tid : %ld, main thread id : %ld\\n", tid ,pthread_self());

    // 让主线程退出,当主线程退出时，不会影响其他正常运行的线程。
    pthread_exit(NULL);

    printf("main thread exit\\n");

    return 0;   // exit(0);
}

连接已终止的线程

/*
    #include <pthread.h>
    int pthread_join(pthread_t thread, void **retval);
        - 功能：和一个已经终止的线程进行连接
                回收子线程的资源
                这个函数是阻塞函数，调用一次只能回收一个子线程
                一般在主线程中使用
        - 参数：
            - thread：需要回收的子线程的ID
            - retval: 接收子线程退出时的返回值
        - 返回值：
            0 : 成功
            非0 : 失败，返回的错误号
*/

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

int value = 10;

void * callback(void * arg) {
    printf("child thread id : %ld\\n", pthread_self());
    // sleep(3);
    // return NULL; 
    // int value = 10; // 局部变量
    pthread_exit((void *)&value);   // return (void *)&value;
} 

int main() {

    // 创建一个子线程
    pthread_t tid;
    int ret = pthread_create(&tid, NULL, callback, NULL);

    if(ret != 0) {
        char * errstr = strerror(ret);
        printf("error : %s\\n", errstr);
    }

    // 主线程
    for(int i = 0; i < 5; i++) {
        printf("%d\\n", i);
    }

    printf("tid : %ld, main thread id : %ld\\n", tid ,pthread_self());

    // 主线程调用pthread_join()回收子线程的资源
    int * thread_retval;
    ret = pthread_join(tid, (void **)&thread_retval);

    if(ret != 0) {
        char * errstr = strerror(ret);
        printf("error : %s\\n", errstr);
    }

    printf("exit data : %d\\n", *thread_retval);

    printf("回收子线程资源成功！\\n");

    // 让主线程退出,当主线程退出时，不会影响其他正常运行的线程。
    pthread_exit(NULL);

    return 0; 
}

pthread_join接收子进程退出是的返回值不能是局部变量，因为进程退出后相应栈空间销毁，会返回随机的地址
另外这个函数是阻塞函数，调用一次只能回收一个子线程，所以主线程可能会长时间阻塞，要避免这点可以使用下面的线程分离函数

线程分离

linux线程控制&线程分离
在任意一个时间点上，线程是可结合（joinable）或者是可分离的（detached）。一个可结合线程是可以被其他线程收回资源和杀死的。在被回收之前，他的存储器资源（栈等）是不释放的。而对于detached状态的线程，其资源不能被别的线程收回和杀死，只有等到线程结束才能由系统自动释放

默认情况，线程状态被设置为结合的。所以为了避免资源泄漏等问题，一个线程应当是被显示的join或者detach的，否则线程的状态类似于进程中的Zombie Process。会有部分资源没有被回收的。用函数pthread_join，当等待线程没有终止时，主线程将处于阻塞状态。如果要避免阻塞，那么在主线程中加入代码pthread_detach(thread_id)或者在被等待线程中加入pthread_detach(thread_self())

/*
    #include <pthread.h>
    int pthread_detach(pthread_t thread);
        - 功能：分离一个线程。被分离的线程在终止的时候，会自动释放资源返回给系统。
          1.不能多次分离，会产生不可预料的行为。
          2.不能去连接一个已经分离的线程，会报错。
        - 参数：需要分离的线程的ID
        - 返回值：
            成功：0
            失败：返回错误号
*/
#include <stdio.h>
#include <pthread.h>
#include <string.h>
#include <unistd.h>

void * callback(void * arg) {
    printf("chid thread id : %ld\\n", pthread_self());
    return NULL;
}

int main() {

    // 创建一个子线程
    pthread_t tid;

    int ret = pthread_create(&tid, NULL, callback, NULL);
    if(ret != 0) {
        char * errstr = strerror(ret);
        printf("error1 : %s\\n", errstr);
    }

    // 输出主线程和子线程的id
    printf("tid : %ld, main thread id : %ld\\n", tid, pthread_self());

    // 设置子线程分离,子线程分离后，子线程结束时对应的资源就不需要主线程释放
    ret = pthread_detach(tid);
    if(ret != 0) {
        char * errstr = strerror(ret);
        printf("error2 : %s\\n", errstr);
    }

    // 设置分离后，对分离的子线程进行连接 pthread_join()
    // ret = pthread_join(tid, NULL);
    // if(ret != 0) {
    //     char * errstr = strerror(ret);
    //     printf("error3 : %s\\n", errstr);
    // }

    pthread_exit(NULL);

    return 0;
}

线程取消

/*
    #include <pthread.h>
    int pthread_cancel(pthread_t thread);
        - 功能：取消线程（让线程终止）
            取消某个线程，可以终止某个线程的运行，
            但是并不是立马终止，而是当子线程执行到一个取消点，线程才会终止。
            取消点：系统规定好的一些系统调用，我们可以粗略的理解为从用户区到内核区的切换，这个位置称之为取消点。
*/

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

void * callback(void * arg) {
    printf("chid thread id : %ld\\n", pthread_self());
    for(int i = 0; i < 5; i++) {
        printf("child : %d\\n", i);
    }
    return NULL;
}

int main() {
    
    // 创建一个子线程
    pthread_t tid;

    int ret = pthread_create(&tid, NULL, callback, NULL);
    if(ret != 0) {
        char * errstr = strerror(ret);
        printf("error1 : %s\\n", errstr);
    }

    // 取消线程
    pthread_cancel(tid);

    for(int i = 0; i < 5; i++) {
        printf("%d\\n", i);
    }

    // 输出主线程和子线程的id
    printf("tid : %ld, main thread id : %ld\\n", tid, pthread_self());

    
    pthread_exit(NULL);

    return 0;
}

线程属性

在线程创建函数中，第二个参数就是线程的属性设置，如果为NULL,就使用默认属性

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

利用代码补全来查看有哪些属性

那么如何设置线程的属性呢？下面是来自牛客课程的代码案例

/*
    int pthread_attr_init(pthread_attr_t *attr);
        - 初始化线程属性变量

    int pthread_attr_destroy(pthread_attr_t *attr);
        - 释放线程属性的资源

    int pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detachstate);
        - 获取线程分离的状态属性

    int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate);
        - 设置线程分离的状态属性
*/     

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

void * callback(void * arg) {
    printf("chid thread id : %ld\\n", pthread_self());
    return NULL;
}

int main() {

    // 创建一个线程属性变量
    pthread_attr_t attr;
    // 初始化属性变量
    pthread_attr_init(&attr);

    // 设置属性
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);

    // 创建一个子线程
    pthread_t tid;

    int ret = pthread_create(&tid, &attr, callback, NULL);
    if(ret != 0) {
        char * errstr = strerror(ret);
        printf("error1 : %s\\n", errstr);
    }

    // 获取线程的栈的大小
    size_t size;
    pthread_attr_getstacksize(&attr, &size);
    printf("thread stack size : %ld\\n", size);

    // 输出主线程和子线程的id
    printf("tid : %ld, main thread id : %ld\\n", tid, pthread_self());

    // 释放线程属性资源
    pthread_attr_destroy(&attr);

    pthread_exit(NULL);

    return 0;
}

tip：获取栈的大小的时候，因为多线程会瓜分栈空间，所以创建子线程前获取和创建子线程后获取有可能不一样，不过貌似系统都会分配一个相等的默认值

补充的资料：linux线程基础----线程属性

线程属性主要包括如下属性：作用域（scope）、栈尺寸（stack size）、栈地址（stack address）、优先级（priority）、分离的状态（detached state）、调度策略和参数（scheduling policy and parameters）

默认的属性为非绑定、非分离、缺省的堆栈、与父进程同样级别的优先级。

线程的分离状态决定一个线程以什么样的方式来终止自己。

线程同步

为什么要线程同步

相较于进程需要通过各种IPC来共享信息进行通信，线程可以很方便的使用全局变量来共享信息。

在下面的代码样例中，我们实现一个多线程买票

/*
    使用多线程实现买票的案例。
    有3个窗口，一共是100张票。
*/

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

// 全局变量，所有的线程都共享这一份资源。
int tickets = 100;

void * sellticket(void * arg) {
    // 卖票
    while(tickets > 0) {
        usleep(6000);
        printf("%ld 正在卖第 %d 张门票\\n", pthread_self(), tickets);
        tickets--;
    }
    return NULL;
}

int main() {

    // 创建3个子线程
    pthread_t tid1, tid2, tid3;
    pthread_create(&tid1, NULL, sellticket, NULL);
    pthread_create(&tid2, NULL, sellticket, NULL);
    pthread_create(&tid3, NULL, sellticket, NULL);

    // 回收子线程的资源,阻塞
    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
    pthread_join(tid3, NULL);

    // 设置线程分离。
    // pthread_detach(tid1);
    // pthread_detach(tid2);
    // pthread_detach(tid3);

    pthread_exit(NULL); // 退出主线程

    return 0;
}

编译运行后会出现一下问题

多个线程可能卖同一张票，或者把票卖出负数了。
这是因为我们的sellticks()函数处于临界区但不是并不是一个原子操作，在多线程的情况下各个线程争夺CPU使用权，线程A刚要卖第一张票就被线程B抢过去，此时线程A和B都会把第1张票卖了，显然这是不合理的。卖票的过程是不应该被拆分的，不然就好几个人做同一个事情，每个人进度不一样，而且还没和其他人沟通过，就容易出现问题。

知识点补充：临界区
临界区是指访问某一共享资源的代码片段，并且这段代码的执行应为原子操作，也就是同时访问同一共享资源的其他线程不应终端该片段的执行。

因此我们需要一种机制来让线程同步，必须确保多个线程不会同时修改同一变量，或者某一线程不会读取正在由其他线程修改的变量。

线程同步的概念

线程同步：即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作，其他线程才能对该内存地址进行操作，而其他线程则处于等待状态。

线程同步的实现一般有下面5种：互斥量，读写锁，条件变量，自旋锁，屏障

互斥锁

摘自牛客网PPT
◼ 为避免线程更新共享变量时出现问题，可以使用互斥量（mutex 是 mutual exclusion的缩写）来确保同时仅有一个线程可以访问某项共享资源。可以使用互斥量来保证对任意共享资源的原子访问。
◼ 互斥量有两种状态：已锁定（locked）和未锁定（unlocked）。任何时候，至多只有一个线程可以锁定该互斥量。试图对已经锁定的某一互斥量再次加锁，将可能阻塞线程或者报错失败，具体取决于加锁时使用的方法。
◼一旦线程锁定互斥量，随即成为该互斥量的所有者，只有所有者才能给互斥量解锁。一般情况下，对每一共享资源（可能由多个相关变量组成）会使用不同的互斥量，每一线程在访问同一资源时将采用如下协议：

  1. 针对共享资源锁定互斥量
  2. 访问共享资源
  3. 对互斥量解锁
/*
    互斥量的类型 pthread_mutex_t
    int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);
        - 初始化互斥量
        - 参数 ：
            - mutex ： 需要初始化的互斥量变量
            - attr ： 互斥量相关的属性，NULL
        - restrict : C语言的修饰符，被修饰的指针，不能由另外的一个指针进行操作。
            pthread_mutex_t *restrict mutex = xxx;
            pthread_mutex_t * mutex1 = mutex;

    int pthread_mutex_destroy(pthread_mutex_t *mutex);
        - 释放互斥量的资源

    int pthread_mutex_lock(pthread_mutex_t *mutex);
        - 加锁，阻塞的，如果有一个线程加锁了，那么其他的线程只能阻塞等待

    int pthread_mutex_trylock(pthread_mutex_t *mutex);
        - 尝试加锁，如果加锁失败，不会阻塞，会直接返回。

    int pthread_mutex_unlock(pthread_mutex_t *mutex);
        - 解锁
*/
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>

// 全局变量，所有的线程都共享这一份资源。
int tickets = 1000;

// 创建一个互斥量
pthread_mutex_t mutex;

void * sellticket(void * arg) {

    // 卖票
    while(1) {

        // 加锁
        pthread_mutex_lock(&mutex);

        if(tickets > 0) {
            usleep(6000);
            printf("%ld 正在卖第 %d 张门票\\n", pthread_self(), tickets);
            tickets--;
        }else {
            // 解锁，分支里不要忘记
            pthread_mutex_unlock(&mutex);
            break;
        }

        // 解锁
       
以上是关于[Linux 高并发服务器]线程的主要内容，如果未能解决你的问题，请参考以下文章
 

 linux学习之高并发服务器篇


 Tomcat优化-提高并发


 Linux服务器高并发实践经历


 Linux + C + Epoll实现高并发服务器(线程池 + 数据库连接池)


 多个请求是多线程吗


 Linux下配置tomcat + apr + native应对高并发