Linux——多线程的控制

Linux------线程的慨念及控制-CSDN博客

文章目录

前言

一、线程函数的认识

1、基本函数的回顾

1、线程的创建pthread_create

2、线程阻塞pthread_join

3、线程退出pthread_exit

2、线程的分离pthread_detach

3、互斥锁初始化函数：pthread_mutex_init

4、互斥锁加锁函数：pthread_mutex_lock

5、互斥锁解锁函数：pthread_mutex_unlock

前言

我们在上一篇博客中学习了单线程的基本控制，及创建、阻塞、终止等操作，这篇博客介绍多个线程的控制。

一、线程函数的认识

1、基本函数的回顾

1、线程的创建pthread_create

cpp 复制代码

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

2、线程阻塞pthread_join

cpp 复制代码

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

3、线程退出pthread_exit

cpp 复制代码

void pthread_exit(void *retval);

2、线程的分离pthread_detach

cpp 复制代码

int pthread_detach(pthread_t thread);

参数说明 ：
- thread：要分离的线程的标识符。
返回值 ：
- 成功时返回 0。
- 出错时返回错误码，可通过 perror 函数输出错误信息。
含义
- 当一个线程被创建时，它的状态默认是可连接的（joinable），这意味着另一个线程可以使用 pthread_join 函数来等待它的结束，并获取其返回值。而线程分离是将线程的状态设置为已分离（detached），这样就不需要其他线程来等待它结束，当线程结束时，其资源会自动被系统回收。
- 分离的线程在结束时会自动释放资源，包括线程的堆栈和其他系统资源，而不需要主线程或其他线程调用 pthread_join 函数来回收。
- 对于一些后台线程，例如日志记录线程、垃圾回收线程等，它们通常在程序的整个生命周期内持续运行，并且不需要主线程等待它们结束或获取它们的返回值。将这些线程设置为分离状态可以简化线程的管理，避免主线程在结束时因为没有调用 pthread_join 而产生资源泄漏。

通俗的说就是当我们主线程不需要等待子线程的返回值时，我们可以让主线程与次线程分离开，不让主线程等待子线程的退出。

代码样例

cpp 复制代码

#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include <vector>
#include <string>
using namespace std;

#define NUM 4

void *Threadroutine(void *args)
{
    int cnt = 0;
    while (true)
    {
        cout << (*((string *)args)).c_str() << endl;
        sleep(1);

        if ((cnt++) == 3)
        {
            break;
        }
    }
    cout<<(*((string *)args)).c_str()<<"运行完了"<<endl;
    return nullptr;
}
int main()
{
    vector<pthread_t> tids;
    for (int i = 0; i < NUM; i++)
    {
        string *name = new string("我是线程-" + to_string(i));
        pthread_t tid;
        tids.push_back(tid);
        pthread_create(&tids[i], nullptr, Threadroutine, name);

    }
        for (auto &th : tids)
        {
            pthread_detach(th);
        }
        for (auto &e : tids)
        {
            pthread_join(e, nullptr);
        }
        while (true)
        {
            cout << "我是主线程，我没有等子线程" << endl;
            sleep(1);
        }
    return 0;
}

我们在把pthread_detach注释掉

这就是分离和不分离的区别，分离以后主线程不用再在join的位置等待子线程推出后再向下运行了。

3、互斥锁初始化函数：`pthread_mutex_init`

cpp 复制代码

int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr);

参数说明 ：
- mutex：一个 pthread_mutex_t 类型的指针，指向要初始化的互斥锁。
- attr：互斥锁属性对象的指针，通常设置为 NULL 表示使用默认属性。
返回值 ：
- 成功时返回 0。
- 出错时返回错误码，可通过 perror 函数输出错误信息。

4、互斥锁加锁函数：`pthread_mutex_lock`

cpp 复制代码

int pthread_mutex_lock(pthread_mutex_t *mutex);

参数说明 ：
- mutex：一个 pthread_mutex_t 类型的指针，指向要加锁的互斥锁。
返回值 ：
- 成功时返回 0。
- 出错时返回错误码，可通过 perror 函数输出错误信息。

5、互斥锁解锁函数：`pthread_mutex_unlock`

cpp 复制代码

int pthread_mutex_unlock(pthread_mutex_t *mutex);

- mutex：一个 pthread_mutex_t 类型的指针，指向要解锁的互斥锁。
返回值 ：
- 成功时返回 0。
- 出错时返回错误码，可通过 perror 函数输出错误信息。

二、介绍锁

线程锁是多线程编程中的一个重要概念，主要用于解决多线程并发访问共享资源时可能出现的竞态条件

1、生活案例介绍锁

我们看图发现有一个房间，而有很多人，这些人想要进入房间，而现在门上有一个锁，这把锁只有一把钥匙在门上面，只有拥有钥匙的人才能进入房间，当a先来拿到了钥匙，然后它进入了房间，b、c、d等人都无法进入房间，因为它们没有钥匙，当a出来了，刚把门锁上，但是又想起来忘东西在里面了，钥匙他还拿着钥匙，这时候其他人还是没有办法进入；

而在计算机的角度来看这个问题就变成了房间是cup，人都是线程，当a在执行一条指令时，其他人只能看着（未进入的线程只能看着），这就是锁的作用

这是最常见的线程锁类型，其核心思想是确保在同一时刻只有一个线程可以访问被保护的资源或执行被保护的代码段。
当一个线程获取到互斥锁时，其他试图获取该锁的线程将被阻塞，直到锁被释放。

那么有什么优势呢？

接下来我们写一个抢票的代码看看加锁和不加锁的区别

cpp 复制代码

#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include <vector>
#include <string>
using namespace std;

#define NUM 4

pthread_mutex_t lock;
int tickets = 1000;
void *Threadroutine(void *args)
{
    while (true)
    {
        pthread_mutex_lock(&lock);
        if (tickets > 0)
        {
            cout << (*((string *)args)).c_str() << "，我抢到了第" << tickets << " 张票" << endl;
            tickets--;
            usleep(200);
        }
        else
        {
            pthread_mutex_unlock(&lock);
            break;

        }
        pthread_mutex_unlock(&lock);
        usleep(1);
    }
    return nullptr;
}
int main()
{
    vector<pthread_t> tids;
    pthread_mutex_init(&lock, nullptr);
    for (int i = 0; i < NUM; i++)
    {
        string *name = new string("我是线程-" + to_string(i));
        pthread_t tid;
        tids.push_back(tid);
        pthread_create(&tids[i], nullptr, Threadroutine, name);
    }
    for (auto &e : tids)
    {
        pthread_join(e, nullptr);
    }


    return 0;
}

不加锁我们看到，线程0和线程1都抢到了第122张票，为什么呢？

我们知道只有cpu有计算能力，我们的代码都是加载到cpu上的寄存器上计算的，而cpu计算时，第一步要将数据加载到cpu上；第二步--；第三步返回数据；

当我们的线程0来了，将122加载当了cpu上时，这个时候线程1和他看到的数据122来了，那么cpu就先将进程0和他的数据放在一边，因为cpu还没有--，所以线程1看到的就是122，cpu执行完线程1的--后，将1返回，这个时候寄存器上的数字为121，cpu又将进程0放回cpu上进程--，因为cpu刚刚把线程0和他的122放到了一边，现在那会的还是122，所以线程0，返回的也是121；

加锁结果如下：

这个时候就是抢钥匙了，就不是同时执行--了，线程0来了，就先将线程0--，然后解锁把钥匙放回去，几个线程谁快，谁先进入cpu，谁来抢票--；

三、细小概念

1、线程安全：

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

常见的线程不安全的情况

不保护共享变量的函数

函数状态随着被调用，状态发生变化的函数返回指向静态变量指针的函数

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

常见的线程安全的情况

每个线程对全局变量或者静态变量只有读取的权限，而没有写入的权限，一般来说这些线程是安全的类或者接口对于线程来说都是原子操作

多个线程之间的切换不会导致该接口的执行结果存在二义性

2、重入：

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

常见不可重入的情况

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

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

常见可重入的情况

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

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

不调用不可重入函数

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

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

3、小概念

临界资源：多线程执行流共享的资源就叫做临界资源
临界区：每个线程内部，访问临界自娱的代码，就叫做临界区

互斥：任何时刻，互斥保证有且只有一个执行流进入临界区，访问临界资源，通常对临界资源起保护作用原子性（后面讨论如何实现）：不会被任何调度机制打断的操作，该操作只有两态，要么完成，要么未完成

总结

程锁是多线程编程中确保数据一致性和程序正确性的重要工具，不同类型的锁适用于不同的场景，合理使用它们可以在保证程序性能的同时避免多线程并发带来的问题。