多线程基础入门【Linux之旅】——上篇【线程控制，线程互斥，线程安全】

嘿！收到一张超美的风景图，希望你每天都能顺心！

前文

结论：在磁盘中储存着的程序文件，他们其实已经被分成许多份大小为4KB的小空间块（被称为页帧）；同时，物理内存中，数据以4KB为单位进行储存（被称作页框）。

当进行IO操作时，例如，向物理内存中导入数据，以4KB形式传递。

回望页表

在曾经，我们学习页表时，只是简单提了一下，今天我们再看页表，了解地更详细。

一，什么是线程

在一个程序里的一个执行路线就叫做线程（thread）。更准确的定义是：线程是“一个进程内部的控制序列”一切进程至少都有一个执行线程。

线程在进程内部运行，本质是在进程地址空间内运行。

在Linux系统中，在CPU眼中，看到的PCB都要比传统的进程更加轻量化。

透过进程虚拟地址空间，可以看到进程的大部分资源，将进程资源合理分配给每个执行流，就形成了线程执行流。

这样子，我们终于能理解这句话了：线程在进程内部执行，同时也是OS调度的基本单位。线程在进程的地址空间中运行，CPU不关心执行的是否是进程还是线程，只要PCB来执行就行。 值得注意的是，Linux只提供轻量级进程，通过pthread库来实现多线程功能！！****Windows对多线程会进行数据结构管理维护，两者方案不同。

说到这里请让我们来重新理解进程：用户视角：进程由 内核数据结构 + 代码和数据，同之前的理解差不多，只是内核数据结构从之前的一个PCB成了多个PCB。内核视角：进程： 进程向OS申请空间，承担系统资源的基本实体。

CPU视角：Linux下，PCB <= 其他系统的PCB。因为linux多线程实现是分配同一个进程的资源，当进程只有一个线程才 ”等于“ 我们曾经所写的代码。话说到这里，有人会问Linux拥有真正的线程吗？？ 答案：没有，多线程只是实现的的一种功能。Linux没有对线程组织管理的数据结构，是轻量级的进程，Linux通过PCB模拟了多线程的功能，同时我们也只有轻量级进程接口。

那怎么实现多线程功能呢？？？ 用 pthread 线程库——Linux自带的原生线程库

二，使用

pthread_create （线程创建）

thread:返回线程ID

attr:设置线程的属性，attr为NULL表示使用默认属性

start_routine:是个函数地址，线程启动后要执行的函数

arg:传给线程启动函数的**参数 **

返回值：成功返回0；失败返回错误码

pthread库，是用用户层的第三方库，不属于C/C++库，所以我们在编译时，需要额外链接pthread库（-pthread）。

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

using namespace std;

void *func(void* str)
{
    while (1)
    {
        cout << "new pthread play..., pid: " << getpid() << endl;    
        sleep(1);
    }
    return nullptr;
}

int main()
{
    pthread_t pt[5];
    for (int i = 0; i < 5; i++)
    {
        pthread_create(pt + i, nullptr, func, (void* )"victor");
    }
    while (1)
    {
        cout << "main pthread play ...,  pid:" << getpid() << endl;
        sleep(1);
    }
    return 0;
}

代码是有了，我们如何查看是否有这么多的线程呢？？？走

PS -aL | grep Thread // 就如我们前面一样的来查看线程

这里同样也验证了，我们之前的话，当一个进程只有一个线程时，其线程也可理解为进程。（线程标号 == PID）

三，线程控制

1 ，线程共享进程数据，但也拥有自己的一部分数据:

1. 独立的线程ID

2. 一组寄存器（需要有寄存器来储存，线程上下文）

3. 独立的栈 （比如说存储产生的临时变量）

1. errno

2. 信号屏蔽字

3. 调度优先级

2， 线程 VS 进程优点

• 创建一个新线程的代价要比创建一个新进程小得多。（代价小）
• 与进程之间的切换相比，线程之间的切换需要操作系统做的工作要少很多。（切换成本低）
• 线程占用的资源要比进程少很多。
• 能充分利用多处理器的可并行数量。
• 在等待慢速I/O操作结束的同时，程序可执行其他的计算任务。
• 计算密集型应用，为了能在多处理器系统上运行，将计算分解到多个线程中实现。
• I/O密集型应用，为了提高性能，将I/O操作重叠。线程可以同时等待不同的I/O操作。

这里解释一下，线程较进程切换代价小的原因：CPU内部有 L1~L3cache(缓存)，每当CPU读取数据时，会向内存中读取，并利用局部性原理用缓存记录下来那周围一部分数据；如果只是切换线程，由于线程之间共享代码和一些数据，那么就大概率CPU能在内部找到所需数据，不需要再次寻址，载入缓存。而如果是切换进程，需要保存旧进程数据，需要重新加载CPU缓存，效率自然就慢下来。

3，pthread_join（等待线程）

功能： 可以阻塞主线程，等待目标线程返回。

thread:线程ID

value_ptr:它指向一个指针，后者指向线程的返回值

返回值：成功返回0；**失败返回错误码 **

retval : 线程结束返回值。那线程出现异常怎么办，答案是：不用关心线程是否出现异常，因为线程一旦出现崩溃，其他线程一同崩溃，进程也崩溃。

成功返回0； 失败，返回错误码。

4，pthread_exit (线程终止)

这里为什么不使用 exit()函数呢？？ 原因是exit() 是进程退出！！而这个是线程退出；execl进程替换也不能在线程中随意使用，execl一旦第一进程进行替换，进程中的代码数据也将被替换，线程也无法继续执行。

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

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

2. 如果thread线程被别的线程调用pthread_ cancel异常终掉,value_ ptr所指向的单元里存放的是常数PTHREAD_CANCELED。

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

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

5， pthread_cancel （线程取消）

thread: 也就是取消线程ID

当一个线程被取消，那么线程退出码，将被设置为PTHREAD_CANCELED(底层就是返回（void*）-1)

一般都是用于：主线程取消副线程的场景

实践一下：

void *func(void* str)
{
    int n = 5;
    int *data = new int[5];
    while (n--)
    {
        cout << "new pthread play..., pid: " << getpid() << endl;
        data[n] = n;    
        sleep(1);
    }
    pthread_exit((void*)111);
}

int main()
{
    pthread_t pt;
    pthread_create(&pt, nullptr, func, (void* )"victor");
    sleep(3);

    pthread_cancel(pt); // 取消线程
    cout << "pthread_cancel get " << endl;

    sleep(5);
    int* ret = nullptr;
    pthread_join(pt, (void**)&ret); // 等待线程退出
    cout << "main pthread play ...,  pid:" << getpid() << " ret :" << (long long )ret  << endl;
    return 0;
}

6. pthread_t 类型

pthread_t到底是什么类型呢？取决于实现。对于Linux目前实现的NPTL实现而言，pthread_t类型的线程ID，本质就是一个进程地址空间上的一个地址。

所以我们所打印新线程的地址是共享内存位置的地址。

另外，在线程中，我们也可以获取当前线程的ID：pthread_self()。

上图中线程局部存储又是什么？？ 答：被__thread 修饰的全局变量

__thread int tmp = 0;  // __thread的结果，让每个线程都有自己被修饰的全局变量，这也是线程局部存储

7. pthread_detach (线程分离)

默认情况下，新创建的线程是joinable的，线程退出后，需要对其进行pthread_join操作，否则无法释放资源，从而造成系统泄漏。如果不关心线程的返回值，主线程一直阻塞，join是一种负担，这个时候，我们可以告诉系统，当线程退出时，自动释放线程资源。

可以是线程组内其他线程对目标线程进行分离，也可以是线程自己分离:

pthread_detach(pthread_self());

joinable和分离是冲突的，一个线程不能既是joinable****又是分离的。当新线程进行分离，主线程再用join进行等待，那么join接口会返回错误码。

void *func(void* str)
{
    pthread_detach(pthread_self());
    pthread_exit((void*)111);
}

int main()
{
    pthread_t pt;
    pthread_create(&pt, nullptr, func, (void* )"new pthread ");

     sleep(1); // 需要等线程分离后，才可进行join等待
     int* ret = nullptr;
     cout << "main thread " << endl;
     int n = pthread_join(pt, (void**)&ret); // 等待线程退出
     cout << "n : " << n << " error : " << strerror(n) << endl; 
    return 0;
}

疑问：既然一个新线程已经分离了，那如果发生异常，是否会影响整个进程呢？

答案： 会的，因为线程依旧是共享着进程资源，如果分离的线程出现异常，依旧会导致整个进程发生退出（崩溃）

四，线程互斥

1. 相关背景概念

临界资源：多线程执行流共享的资源就叫做临界资源。

临界区：每个线程内部，访问临界资源的代码，就叫做临界区。

互斥：任何时刻，互斥保证有且只有一个执行流进入临界区，访问临界资源，通常对临界资源起保护作用。

原子性（后面讨论如何实现）：不会被任何调度机制打断的操作，该操作只有两态，要么完成，要么未完成。

通过下面代码，我们来理解为什么需要线程互斥：

int ticket = 1000;
void* getticket(void* str)
{
    // 打印并进行取票
    while(ticket > 0)
    {
        usleep(1000);
        cout << "getticket : " << ticket << endl;
        ticket--;
    }
    pthread_exit(nullptr);
}

int main()
{
    pthread_t t1, t2, t3,t4;
  
    pthread_create(&t1, nullptr, getticket, nullptr);
    pthread_create(&t2, nullptr, getticket, nullptr);
    pthread_create(&t3, nullptr, getticket, nullptr);
    pthread_create(&t4, nullptr, getticket, nullptr);

    pthread_join(t1, nullptr);
    pthread_join(t2, nullptr);
    pthread_join(t3, nullptr);
    pthread_join(t4, nullptr);
    return 0;
}

为什么可能无法获得争取结果？

1. while判断条件为真以后，代码可以并发的切换到其他线程。

2. usleep这个模拟漫长业务的过程，在这个漫长的业务过程中，可能有很多个线程会进入该代码段。

3. --ticket操作本身就不是一个原子操作。

--操作并不是原子操作，而是对应三条汇编指令：

load： 将共享变量ticket从内存加载到寄存器中

update: 更新寄存器里面的值，执行-1操作

store： 将新值，从寄存器写回共享变量ticket的内存地址

总之：

票出现负数原因：我们的getticket函数是可重入函数。由于CPU调度切换原因导致，数据出现异步。

大部分情况，线程使用的数据都是局部变量（比如说栈上的变量），变量的地址空间在线程栈空间内，这种情况，变量归属单个线程，其他线程无法获得这种变量。 但有时候，很多变量都需要在线程间共享，这样的变量称为共享变量，可以通过数据的共享，完成线程之间的交互。 多个线程并发的操作共享变量，会带来一些问题。

不太理解数据异步可以参考下面这个例子：

2. 互斥量

为了解决下面的问题：

代码必须要有互斥行为：当代码进入临界区执行时，不允许其他线程进入该临界区。

如果多个线程同时要求执行临界区的代码，并且临界区没有线程在执行，那么只能允许一个线程进入该临界区。

如果线程不在临界区中执行，那么该线程不能阻止其他线程进入临界区。

要做到这三点，本质上就是需要一把锁。Linux上提供的这把锁叫互斥量。

接口：

1），初始化互斥量

pthread_mutex_t 类型，本质上是一个联合体。

两种方法：

方法1，静态分配（全局锁）：

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER

全局锁，可以不用考虑销毁锁。

方法2，动态分配（局部锁）：

int pthread_mutex_init (pthread_mutex_t * restrict mutex， const pthread_mutexattr_t * restrict attr)；

参数：

mutex：要初始化的互斥量

attr：NULL

通过函数设置的锁，在 

生命周期快结束时，需要销毁局部锁。

2），互斥量加锁与解锁

int pthread_mutex_lock(pthread_mutex_t *mutex);

int pthread_mutex_unlock(pthread_mutex_t *mutex);

返回值：成功返回0,失败返回错误号。

调用pthread_ lock 时，可能会遇到以下情况：

情况一：互斥量处于未锁状态，该函数会将互斥量锁定，同时返回成功。

情况二：发起函数调用时，其他线程已经锁定互斥量，或者存在其他线程同时申请互斥量，但没有竞争到互斥量，那么*pthread_ lock***调用会陷入阻塞(**执行流被挂起)，等待互斥量解锁。

3），销毁互斥量

销毁互斥量需要注意：

使用PTHREAD_ MUTEX_ INITIALIZER初始化的互斥量不需要销毁 。不要销毁一个已经加锁的互斥量

已经销毁的互斥量，要确保后面不会有线程再尝试加锁。（尽量不销毁互斥量，互斥量尽量用PTHREAD_MUTEX_INITIALIZER初始化）

改善后的抢票系统：

pthread_mutex_t  mutex = PTHREAD_MUTEX_INITIALIZER;
int ticket = 1000;

void* getticket(void* str)
{
    
    // 打印并进行取票
     while(1)
    {
        pthread_mutex_lock(&mutex); // 加锁
        if (ticket > 0 )
        {     
        usleep(1000);
        ticket--;
        pthread_mutex_unlock(&mutex); // 解锁
        // 为什么要将cout代码置出临界区？？
        // 我们需要注重临界区代码的颗粒度，颗粒度越小，越好。
        // 对于多线程访问临界资源，我们需要考虑效率问题。将无关紧要的代码优化掉，提高临界区的颗粒，细密度。
        cout << (char*)str << " getticket : " << ticket << endl;
        }else
        {
            pthread_mutex_unlock(&mutex);
            break;
        }
    pthread_exit(nullptr);
}

int main()
{
    pthread_t t1, t2, t3,t4;
    pthread_create(&t1, nullptr, getticket, (void*)"线程一：");
    pthread_create(&t2, nullptr, getticket, (void*)"线程二：");
    pthread_create(&t3, nullptr, getticket, (void*)"线程三：");
    pthread_create(&t4, nullptr, getticket, (void*)"线程四：");

    pthread_join(t1, nullptr);
    pthread_join(t2, nullptr);
    pthread_join(t3, nullptr);
    pthread_join(t4, nullptr);
    return 0;
}

错误代码反思分享：

我们知道上面是对临界资源进行修改。那我们仅仅是访问临界资源呢？？那我们是否可以不用跟其他线程进行竞争锁，直接访问！

回答：从语法上来说是允许的。但这是错误的编码思想。即使是访问临界资源，也需要进行申请锁。

理解锁

1. 对临界区代码进行加锁，使临界区的执行是穿行的。即使是CPU调度，持有锁的线程被换下，其他线程也执行不了临界区代码。

2. 多个线程线程竞争锁，锁本身也是一种共享资源，那如何保护锁的安全性？ 答：申请锁与释放锁，底层执行操作是原子操作。

3. 锁的底层原理：
   

补充重入 & 线程安全概念

线程安全：多个线程并发同一段代码时，不会出现不同的结果。常见对全局变量或者静态变量进行操作，并且没有锁保护的情况下，会出现该问题。

重入：同一个函数被不同的执行流调用，当前一个流程还没有执行完，就有其他的执行流再次进入，我们称之为重入。一个函数在重入的情况下，运行结果不会出现任何不同或者任何问题，则该函数被称为可重入函数，反之，则不可重入函数。

3. 常见的线程不安全的情况

不保护共享变量的函数

函数状态随着被调用，状态发生变化的函数

返回指向静态变量指针的函数

调用线程不安全函数的函数

**常见的线程安全的情况 **

每个线程对全局变量或者静态变量只有读取的权限，而没有写入的权限，一般来说这些线程是安全的类或者接口对于线程来说都是原子操作多个线程之间的切换不会导致该接口的执行结果存在二义性。

**常见不可重入的情况 **

调用了malloc/free函数，因为malloc函数是用全局链表来管理堆的

调用了标准I/O库函数，标准I/O库的很多实现都以不可重入的方式使用全局数据结构

可重入函数体内使用了静态的数据结构

常见可重入的情况

不使用全局变量或静态变量

不使用用malloc或者new开辟出的空间

不调用不可重入函数

不返回静态或全局数据，所有数据都有函数的调用者提供

使用本地数据，或者通过制作全局数据的本地拷贝来保护全局数据

**可重入与线程安全联系 **

函数是可重入的，那就是线程安全的。（概率晦涩，我们知道这个即可）

函数是不可重入的，那就不能由多个线程使用，有可能引发线程安全问题。

如果一个函数中有全局变量，那么这个函数既不是线程安全也不是可重入的。

**可重入与线程安全区别 **

可重入函数是线程安全函数的一种。

线程安全不一定是可重入的，而可重入函数则一定是线程安全的。

如果将对临界资源的访问加上锁，则这个函数是线程安全的，但如果这个重入函数若锁还未释放则会产生死锁，因此是不可重入的。

下期：多线程——下篇

结语

本小节就到这里了，感谢小伙伴的浏览，如果有什么建议，欢迎在评论区评论，如果给小伙伴带来一些收获请留下你的小赞，你的点赞和关注将会成为博主创作的动力。