Linux知识点 -- Linux多线程（二）

最新推荐文章于 2024-06-14 14:37:55 发布
最新推荐文章于 2024-06-14 14:37:55 发布
阅读量231 收藏 1
点赞数
分类专栏： Linux 文章标签： linux 运维 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kissland96166/article/details/132332913
版权

Linux知识点 – Linux多线程（二）

文章目录

一、线程互斥

1.背景概念

  • 临界资源：多线程执行流共享的资源就叫做临界资源；
  • 临界区：每个线程内部,访问临界资源的代码，就叫做临界区；
  • 互斥：任何时刻，互斥保证有且只有一个执行流进入临界区, 访问临界资源，通常对临界资源起保护作用；
  • 原子性：不会被任何调度机制打断的操作,该操作只有两态,要么完成，要么未完成；

2.多线程访问同一个全局变量

下面实现一个抢票代码，多线程共同抢票，都访问同一个全局变量tickets，每次访问都 - -tickets：

#include <iostream>
#include <string>
#include <cstdio>
#include <cstring>
#include <cerrno>
#include <unistd.h>
#include <pthread.h>

using namespace std;

int tickets = 1000;


void *getTickets(void *args)
{
    (void)args;
    while (true)
    {
        if(tickets > 0)
        {
            usleep(1000);
            printf("%p: %d\n", pthread_self(), tickets);
            tickets--;
        }
        else
        {
            break;
        }
    }
}

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

    pthread_join(t1, nullptr);
    pthread_join(t2, nullptr);
    pthread_join(t3, nullptr);

    return 0;
}

运行结果：
在这里插入图片描述
最终将tickets的数量减到了-1，但我们发现判断条件是tickets > 0才执行 - -操作；
并发访问的时候，导致了数据不一致的问题；

  • 解释：
    tickets - -这个操作翻译成汇编语句，一共有三步操作：
    （1）读取内存数据到cpu的寄存器中；
    （2）cpu内部进行计算 - -；
    （3）将结果写回内存中
    把数据读取到寄存器，就是将数据读取到执行流的上下文数据；
    因为这个tickets - - 的运算过程不是原子的，线程在运行的任何时候都有可能被切换出去，因此会发生以下的情况：
    当线程1执行完第二步的时候，被切走了，由线程2继续执行这个- - 操作；
    线程2执行完后将数据写回内存，当线程2一直执行一定时间后，将最后结果（5000）写入内存；
    此时切回了进程1，从第三步继续执行，将结果写入内存，内存中的结果又被写成了9999；
    这样就引发了因为切换问题导致的数据不一致；

3.加锁保护

为了解决多线程引发的数据不一致问题，可以为临界区代码加锁：

  • 锁的初始化：
    在这里插入图片描述
    自行初始化：
    在这里插入图片描述
    全局内定义的静态锁，使用宏初始化：
    在这里插入图片描述
  • 加锁与解锁：
    在这里插入图片描述

在临界区加锁：加锁的意义在于，在一个时刻，只允许一个执行流访问加锁的代码，将这段代码变成串行运行的；
任何一个时刻，只允许一个线程获得这把锁，其他线程都在等待；
直到拿到锁的线程最终释放掉，其他线程才可以拿到；
相当于加锁和解锁之间的代码只可以串行通信，其他代码都可以并行；
在这里插入图片描述

全局静态的锁：

//全局静态的锁，使用宏初始化
pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;//pthread_mutex_t就是原生线程库提供的一个数据类型

void *getTickets(void *args)
{
    (void)args;
    while (true)
    {
        pthread_mutex_lock(&mtx);//为临界区代码加锁
        if(tickets > 0)
        {
            usleep(1000);
            printf("%p: %d\n", pthread_self(), tickets);
            tickets--;
        }
        else
        {
            break;
        }
    }
}

解锁：
在这里插入图片描述
不能在这里解锁，因为如果线程执行完break之后，就不会执行解锁代码，而这把锁是全局的，还处于被该线程修改的状态，其他线程就无法拿到锁了；
应该在下面的地方解锁：

//全局静态的锁，使用宏初始化
pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;//pthread_mutex_t就是原生线程库提供的一个数据类型

void *getTickets(void *args)
{
    (void)args;
    while (true)
    {
        pthread_mutex_lock(&mtx);//为临界区代码加锁
        if(tickets > 0)
        {
            usleep(1000);
            printf("%p: %d\n", pthread_self(), tickets);
            tickets--;
            pthread_mutex_unlock(&mtx);//解锁
        }
        else
        {
        	//如果线程加锁后直接运行到这里，在这里也可以解锁
            pthread_mutex_unlock(&mtx);//解锁
            break;
        }
    }
}

加锁和解锁之间的代码叫做临界区；

运行：
固定休眠时间可能会导致只有一个线程在跑，可以随即休眠时间；

#include <iostream>
#include <string>
#include <cstdio>
#include <cstring>
#include <cerrno>
#include <unistd.h>
#include <pthread.h>
#include <ctime>

using namespace std;

int tickets = 1000;

//全局静态的锁，使用宏初始化
pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;//pthread_mutex_t就是原生线程库提供的一个数据类型

void *getTickets(void *args)
{
    (void)args;
    while (true)
    {
        pthread_mutex_lock(&mtx);//为临界区代码加锁
        if(tickets > 0)
        {
            usleep(rand()%1500);
            printf("%s: %d\n", (char*)args, tickets);
            tickets--;
            pthread_mutex_unlock(&mtx);//解锁
        }
        else
        {
            //如果线程加锁后直接运行到这里，在这里也可以解锁
            pthread_mutex_unlock(&mtx);//解锁
            break;
        }
        usleep(rand()%2000);
    }
}

int main()
{
    srand((unsigned long)time(nullptr) ^ getpid());
    pthread_t t1, t2, t3;
    pthread_create(&t1, nullptr, getTickets, (void*)"thread one");
    pthread_create(&t2, nullptr, getTickets, (void*)"thread two");
    pthread_create(&t3, nullptr, getTickets, (void*)"thread three");

    pthread_join(t1, nullptr);
    pthread_join(t2, nullptr);
    pthread_join(t3, nullptr);

    return 0;
}

结果：
在这里插入图片描述
注：加锁的时候，一定要保证加锁的粒度越小越好，因为加锁会导致进程互斥，造成临界区代码只能串行访问，影响效率；

局部的锁：
在这里插入图片描述
第一个参数是锁的地址，第二个是锁的属性；

#include <iostream>
#include <string>
#include <cstdio>
#include <cstring>
#include <cerrno>
#include <unistd.h>
#include <pthread.h>
#include <ctime>

using namespace std;

int tickets = 1000;

//全局静态的锁，使用宏初始化
//pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;//pthread_mutex_t就是原生线程库提供的一个数据类型

#define THREAD_NUM 5

class ThreadData
{
public:
    ThreadData(const string &n, pthread_mutex_t *pm)
        : tname(n),
          pmtx(pm)
    {}

public:
    string tname;//线程名
    pthread_mutex_t *pmtx;//锁
};

void *getTickets(void *args)
{
    ThreadData* td = (ThreadData*)args;//接收对象
    while (true)
    {
        pthread_mutex_lock(td->pmtx);//为临界区代码加锁
        if(tickets > 0)
        {
            usleep(rand()%1500);
            printf("%s: %d\n", td->tname.c_str(), tickets);
            tickets--;
            pthread_mutex_unlock(td->pmtx);//解锁
        }
        else
        {
            //如果线程加锁后直接运行到这里，在这里也可以解锁
            pthread_mutex_unlock(td->pmtx);//解锁
            break;
        }
        usleep(rand()%2000);
    }
    delete td;
    return nullptr;
}

int main()
{
    pthread_mutex_t mtx;
    pthread_mutex_init(&mtx, nullptr);//局部锁初始化
    srand((unsigned long)time(nullptr) ^ getpid());
    pthread_t t[THREAD_NUM];
    //多线程抢票逻辑
    for(int i = 0; i < THREAD_NUM; i++)
    {
        string name = "thread ";
        name += to_string(i + 1);

        ThreadData *td = new ThreadData(name, &mtx);//创建对象
        pthread_create(t + i, nullptr, getTickets, (void*)td);//创建线程的时候，穿的参数也可以是对象指针
    }

    for(int i = 0; i < THREAD_NUM; i++)
    {
        pthread_join(t[i], nullptr);
    }


    pthread_mutex_destroy(&mtx);//局部锁的销毁

    return 0;
}

在上面的代码中，创建了一个类保存线程的信息和锁的指针，创建线程的时候，给回调函数传的参数也可以传这个对象，这样就把线程属性和局部锁的指针都传进去了，在回调函数中就可以进行使用；

运行结果：
在这里插入图片描述

4.问题

  • 加锁之后，线程在临界区中是否会切换？
    会被切换，但是不会出问题；因为该线程是持有锁被切换的，所以其他抢票线程要执行临界区代码，也必须先申请锁，但是锁已经被该线程申请了，其他线程就无法申请成功，因此，就不会让其他线程进入临界区，保证了临界区中数据的一致性；

  • 一个线程，不申请锁，就是单纯的访问临界资源，这是错误的编码方式；

  • 当一个线程持有锁，在其他线程看来，该线程就是原子的；

  • 所本身就是一种共享资源，那么谁来保证锁的安全呢？
    为了保证锁的安全，申请和释放锁，必须是原子的；

5.锁的实现

  • exchange或swap汇编指令：
    以一条汇编指令的方式，将内存和CPU寄存器的数据进行交换；站在汇编的角度，只有一条汇编语句，就认为该语句的执行是原子的；

  • 在执行流视角，是如何看待COU上面的寄存器的？
    CPU内部的寄存器，本质叫做当前执行流的上下文，这些寄存器的空间是被所有执行流共享的，但是寄存器的内容，是被每一个执行流私有的，当执行流切换的时候，会将寄存器内的数据（上下文数据）一并带走；

  • 加锁和解锁的汇编代码：（伪代码）
    在这里插入图片描述
    核心的语句就是下面这句：
    在这里插入图片描述
    将寄存器的内容和锁的内容交换，这是一行汇编代码，是原子的；
    多线程申请锁的可能的情况：
    在这里插入图片描述
    内存mutex中的1只能被一个线程交换，如果A线程已经执行了这一条指令，将al寄存器的值（0）和mutex的值（1）交换；
    交换完成后，mutex的值就变为了0，相当于锁已经被A线程拿走了，此时线程A被切换了，连带着寄存器al中的值一起带走；
    当另一个线程B来的时候，内存mutex中这个1已经被上一个线程交换了；
    现在mutex中的值是0，第二个线程交换完后将0交换到了寄存器al中，因此只能等待；
    释放锁就是再将线程寄存器al的内容和内存mutex的内容再交换回来；

二、线程安全

1.可重入与线程安全

  • 可重入：
    在这里插入图片描述
    可重入是针对函数而言的；
  • 线程安全：
    在这里插入图片描述
    线程安全是用来描述线程的；

2.常见情况

  • 线程不安全：
    在这里插入图片描述

  • 线程安全：
    在这里插入图片描述

  • 不可重入：
    在这里插入图片描述

  • 可重入：
    在这里插入图片描述

3.可重入与线程安全的联系

  • 函数是可重入的，那就是线程安全的；
  • 函数是不可重入的，那就不能由多个线程使用，有可能引发线程安全问题；
  • 如果一个函数中有全局变量，那么这函数既不是线程安全的也不是可重入的；
  • 线程安全不一定是可重入的；

三、死锁

1.死锁概念

死锁：是指再一组线程中的各个线程均占有不会释放的资源，但因互相申请被其他进程所占的资源而初一的一种永久等待的状态；

  • 两个线程同时申请对方已有的锁，形成互相申请对方资源的一种环路情况；

同一个线程反复申请同一把锁，也会造成死锁：

#include <iostream>
#include <string>
#include <cstdio>
#include <cstring>
#include <cerrno>
#include <unistd.h>
#include <pthread.h>
#include <ctime>
#include<cassert>

using namespace std;

int tickets = 1000;

#define THREAD_NUM 5

class ThreadData
{
public:
    ThreadData(const string &n, pthread_mutex_t *pm)
        : tname(n),
          pmtx(pm)
    {}

public:
    string tname;//线程名
    pthread_mutex_t *pmtx;//锁
};

void *getTickets(void *args)
{
    ThreadData* td = (ThreadData*)args;//接收对象
    while (true)
    {
        int n = pthread_mutex_lock(td->pmtx);//为临界区代码加锁
        assert(n == 0);
        if(tickets > 0)
        {
            usleep(rand()%1500);
            printf("%s: %d\n", td->tname.c_str(), tickets);
            tickets--;
            int n = pthread_mutex_lock(td->pmtx);//听一个进程反复申请同一把锁，也会造成死锁
            assert(n == 0);
        }
        else
        {
            int n = pthread_mutex_lock(td->pmtx);
            assert(n == 0);
            break;
        }
        usleep(rand()%2000);
    }
    delete td;
    return nullptr;
}

int main()
{
    pthread_mutex_t mtx;
    pthread_mutex_init(&mtx, nullptr);//局部锁初始化
    srand((unsigned long)time(nullptr) ^ getpid());
    pthread_t t[THREAD_NUM];
    //多线程抢票逻辑
    for(int i = 0; i < THREAD_NUM; i++)
    {
        string name = "thread ";
        name += to_string(i + 1);

        ThreadData *td = new ThreadData(name, &mtx);//创建对象
        pthread_create(t + i, nullptr, getTickets, (void*)td);//创建线程的时候，穿的参数也可以是对象指针
    }

    for(int i = 0; i < THREAD_NUM; i++)
    {
        pthread_join(t[i], nullptr);
    }

    pthread_mutex_destroy(&mtx);//局部锁的销毁

    return 0;
}

运行结果：
在这里插入图片描述
该线程运行了一次就卡住不动了，进入了死锁状态；

2.死锁的条件

  • 死锁的四个必要条件（全部满足即造成死锁）：
    （1）互斥条件：一个资源每次只能被一个执行流使用；
    （2）请求与保持条件：一个执行流因请求资源而阻塞时，对已获得的资源保持不放；
    （3）不剥夺条件：一个执行流已获得的资源，在末使用完之前，不能强行剥夺；
    （4）循环等待条件：若干执行流之间形成一种头尾相接的循环等待资源的关系；

3.避免死锁的方法

（1）破坏死锁的四个必要条件的其中一个；

  • 互斥：可不可以不加锁；
  • 请求与保持：申请锁时可以使用trylock，如果锁被占有，就返回错误码，连续申请若干次，不成功，就把自己的锁释放掉，不会导致线程阻塞；

（2）加锁顺序一致；
（3）避免锁未释放的场景；
（4）资源一次性分配；

蝎子莱莱xo
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux多线程各个函数示例代码.zip
02-11
本代码配套我的博客里的多线程编程, 这里系统性地进行讲解,附带每个知识点的代码,快速入门Linux的多线程编程! 博客地址:https://blog.csdn.net/weixin_40519315/article/details/104211643
Linux下多线程编程-Pthread与Semaphore的使用.doc
10-10
Linux 下多线程编程-Pthread 与 Semaphore 的使用 Linux 下的多线程编程是通过使用 POSIX 线程接口，称为 pthread 实现的。要编写 Linux 下的多线程程序，需要使用头文件 pthread.h，连接时需要使用库 libpthread.a...
嵌入式软件开发技术：第5章 嵌入式Linux多线程编程.ppt
05-31
本章节将详细介绍嵌入式Linux多线程编程的基本概念、线程的创建、同步和互斥、线程属性、多线程实验等方面的知识点。 1. 线程基本概念 在Linux系统中，线程是进程内独立的一条运行路线，处理器调度的最小单元，也...
Linux内核知识点汇总
05-24
本文将从多个角度对Linux内核进行了系统的总结，涵盖了内核的概念、结构、进程管理、内存管理、文件系统管理等方面的知识点。 1. 应用程序如何和内核进行通信？ 应用程序可以通过系统调用来与内核进行通信。系统...
Linux系统下基于Tcp的多线程大文件上传实现.pdf
09-06
知识点1：多线程编程 * 多线程编程是指在一个进程中同时执行多个线程，以提高程序的执行效率。 * 在Linux系统下，多线程编程可以使用pthread库来实现。 * 本文中，使用pthread库来创建多个线程，每个线程负责传输...
解决 Linux 和 Java 1.8 中上传中文名称图片报错问题
appearappear的博客
06-12 249
在 Linux 系统和 Java 1.8 中，当尝试上传含有中文名称的图片时，可能会遇到以下错误提示：为了解决这个问题，可以采取以下方法：在 Docker 的 中添加如下参数：Dockerfile使用以下命令启动 Java 程序，添加 参数：通过以上配置，确保了在启动 Java 程序时，使用了 UTF-8 编码，这样可以正确处理含有中文名称的文件，避免了报错问题的发生。3.5
嵌入式Linux系统编程 — 3.4 access、chmod和 umask函数修改文件访问权限
几度春风里的博客
06-09 932
文件的权限检查不仅讨论文件本身的权限，还需要涉及到文件所在目录的权限， 只有同时都满足了，才能通过操作系统的权限检查，进而才可以对文件进行相关操作；所以，程序当中对文件进行相关操作之前，需要先检查执行进程的用户是否对该文件拥有相应的权限。需要进行权限检查的文件路径。F_OK：检查文件是否存在R_OK：检查是否拥有读权限W_OK：检查是否拥有写权限X_OK：检查是否拥有执行权限检查项通过则返回 0，表示拥有相应的权限并且文件存在；
Ollama在MacOS、Linux本地部署千问大模型及实现WEB UI访问
最新发布
派大夏的博客
06-14 589
阿里通义千问发布了Qwen2，提供了0.5B～72B的量级模型，在​​Ollama官网​​可以搜索qwen2查看，本文提供了Ollama的下载（在线/离线安装）、Ollama运行模型、使用WebUI连接模型以及页面简单配置。总体还是比较简单的，更高阶的玩法，看小伙伴的反馈，后面更新比如自定义智能体、训练等。
Linux基础命令
威桑的博客
06-11 797
常见基础Linux命令
【Linux下的动态链接和静态链接 及 调用libevent库函数的可执行文件无法正常运行情况剖析】
一起学习进步！
06-09 321
静态链接是指在编译时，将程序所依赖的函数或数据直接复制到最终的可执行文件中。这意味着可执行文件包含了程序运行所需的所有代码和数据。动态链接是指在运行时，程序所依赖的函数或数据从外部的共享库（shared library）中加载。这意味着可执行文件只包含了必要的引用信息，而实际的代码和数据则存储在外部的共享库中。
NVIDIA Jetson Linux 35.3.1-开发指南-Jetson软件架构
FREEDOM_X的专栏
06-11 747
下图显示了NVIDIA®Jetson™Linux架构。以下部分描述了每个模块的组件。在本开发人员指南或其他地方，许多组件的名称是指向组件主留档的链接。一些组件具有带有附加描述的单独链接。
MySQl基础----Linux下搭建mysql软件及登录和基本使用（附实操图超简单一看就会）
溟洵的博客
06-10 766
本章非常基础包括如何在Linux上搭建（==当然上面的SQL语句你在其他能执行SQL语句的软件上也能正常执行，并非一定要在Linux环境下==）和mysql的基本使用
Linux_应用篇(17) FrameBuffer 应用编程
weixin_41252596的博客
06-13 781
linux FrameBuffer 应用编程
linux中安装jdk
qq_37559701的博客
06-13 202
1.查看jdk是否安装。
Linux中的EINTR和EAGAIN错误码
weixin_62476152的博客
06-14 209
EINTR和EAGAIN是Linux系统中常见的错误码，它们反映了系统调用的状态和资源可用性。了解这两个错误码的含义和常见场景，可以帮助我们更好地进行进程间通信和同步，以及正确地处理错误和异常情况。
Linux Mint 21.3简介
地球空间
06-11 281
1. Cinnamon 6.0桌面环境：Linux Mint 21.3采用了最新的Cinnamon 6.0桌面环境，带来了新的功能和改进，例如支持Wayland会话（尽管仍处于实验性阶段）、改进的声音和电源小部件、对AVIF图像格式的新支持、屏幕缩放新手势、菜单详细信息选项、75%缩放以及窗口不透明度键绑定等。4. 应用程序更新：Linux Mint 21.3带来了应用程序的更新，包括Nemo文件管理器、Cinnamon桌面和小部件、扩展和主题等的改进。
Linux之date日期和时间命令
lisankongjian的博客
06-08 111
Linux之date日期和时间命令，修改Linux时间
Linux常见命令的缩写来源单词
学习，学无止境
06-09 271
基本文件和目录操作命令 ls - list（列出目录内容） -l：long format（长格式） -d：directory（目录） 归档和压缩命令 tar - tape archive（磁带档案） -c：create（创建） -v：verbose（详细） -f：file（文件） -z：gzip（当与tar结合使用时，表示使用gzip压缩） 用户和权限管理命令 chmod - change mode（改变模式/权限） chown - change owner（改变所有者）
6_1 Linux 用户管理
2302_79253478的博客
06-09 476
1. 用户与组重要的配置文件/etc/passwd:用户基本信息配置文件/etc/shadow:用户密码信息配置文件/etc/group:组基本信息配置文件/etc/gshadow:组管理信息配置文件2. Linux系统执行useradd命令，会完成那些操作？会在/etc/passwd增加一行信息会在/etc/shadow增加一行信息会在/home新增用户家目录会在/var/spool/mail增加用户邮件文件会在/etc/group增加一行组信息。
linux多线程服务器编程
06-10
Linux多线程服务器编程是指在Linux操作系统下，使用多线程技术开发服务器应用程序。多线程技术可以提高服务器的并发处理能力，以便更好地满足大规模并发访问的需求。 在Linux下，可以使用多种编程语言进行多线程编程，如C/C++、Java等。常见的多线程编程库有：pthread、boost、OpenMP等。 在多线程服务器编程中，需要注意以下几点： 1. 线程安全：多个线程访问同一资源时，需要进行线程同步，以免出现数据竞争等问题。 2. 处理请求：服务器需要处理客户端发送的请求，并且响应客户端的请求。多线程技术可以提高服务器的并发处理能力，以便更好地满足大规模并发访问的需求。 3. 负载均衡：服务器需要进行负载均衡，以便更好地分配处理请求的线程。 4. 可扩展性：服务器需要具有可扩展性，以便在需要时可以增加更多的线程来提高服务器的并发处理能力。 总之，Linux多线程服务器编程需要开发人员具备扎实的多线程编程知识和经验，以便更好地满足大规模并发访问的需求。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值