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、线程安全：

常见的线程不安全的情况

常见的线程安全的情况

2、重入：

常见不可重入的情况

常见可重入的情况

3、小概念

总结

前言

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

一、线程函数的认识

1、基本函数的回顾

1、线程的创建pthread_create

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

2、线程阻塞pthread_join

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

3、线程退出pthread_exit

void pthread_exit(void *retval);

2、线程的分离pthread_detach

int pthread_detach(pthread_t thread);

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

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

代码样例

#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`

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`

int pthread_mutex_lock(pthread_mutex_t *mutex);

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

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

int pthread_mutex_unlock(pthread_mutex_t *mutex);

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

二、介绍锁

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

1、生活案例介绍锁

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

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

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

那么有什么优势呢？

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

#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；

加锁结果如下：