多线程之你真的了解Spin_lock吗?(四)

Linux中自旋锁实现的基本原理之经典 将互斥锁替换为自旋锁之后,测试结果打印也是没有问题的,并且通过对比可以发现,替换为自旋锁之后,程序运行所耗费的时间明显变短了,说明自旋锁确实比互斥锁效率要高。原型:int pthread_spin_init(pthread_spinlock_t *lock ,int pshared);自旋锁本质上是一把锁,在访问共享资源之前对自旋锁进行上锁,在访问完成后释放自旋锁(解锁)i++) //循环loops次。i++) //单线程循环loops次。i++) //单线程循环loops次。... 阅读详情

1. 写在之前

在阅读本文前,如果下面的问题您都能回答出来,那么本文你可以从略。

  • Pthread_spin_lock和Spin_lock的区别?
  • Spin_lock对于单核非抢占内核,为何是无意义的?
  • 那么中断处理函数的执行是在内核态或者用户态呢?

如果上面3个问题,您都能回答出来,说明本文所讲述的内容,您大体上都了解了。本文基于Pthread_spin_lock探究下其用法及进行相关的实验。

2. 基本概念

首先不要搅浑任务调度和内核抢占,两个概念是指着不同的角度说的。内核抢占是对于处于内核态的进程是否能被调度的描述,而任务调度是指进程处于用户态时发生的调度。那么对于非抢占内核和抢占内核,在用户态的调度是没有区别的,但是在内核态对待调度行为的差别区分了抢占内核和非抢占内核。以下描述取自 《ULK 3th 》:

in nonpreemptive kernels, the current process cannot be replaced unless it is about to switch to User Mode.

以下内容摘自维基百科:

Kernel preemption is a method used mainly in monolithic and hybrid kernels where all or most device drivers are run in kernel space, whereby the scheduler is permitted to forcibly perform a context switch (i.e. preemptively schedule; on behalf of a runnable and higher priority process) on a driver or other part of the kernel during its execution, rather than co-operatively waiting for the driver or kernel function (such as a system call) to complete its execution and return control of the processor to the scheduler.

本文不打算介绍内核调度机制,但是基本的概念要明白:在内核可抢占的系统中,调度可以发生在内核态的执行过程,换句话说,对于非抢占的系统中,调度只能等内核态的执行流执行完,不要混淆调度算法中每个进程时间片耗尽时任务调度,对于非抢占和抢占内核,在用户态的切换应该是没有区别的。区别只发生在一种场景:在内核态的任务调度的处理方式!
  回过头来思考第一个问题:
Pthread_spin_lock和Spin_lock的区别?
答案应该是即相互区别又相互联系,前者用在用户态的编程,后者用在内核态的编程。如果进行应用程序的开发,那么前者是我们的实现spin_lock的手段。但当我们进行驱动编程或者内核态进程编程时,后者就是我们实现spin_lock的手段。

第二个问题:Spin_lock对于单核非抢占内核,为何是无意义的?

以下资料来自quora, 该回答太棒了,因为比较多,笔者节选了其中部分。

Time Sliced Scheduling: In this scenario what happens is, Process A acquires the spin lock for resource X and then having exhausted its time slice is swapped for Process B. The Process B attempts to acquire the spin lock and starts busy-waiting for the lock to be free’d. After a while, it completes its time slice and is Process A is swapped back on the CPU and continues processing. This cycle repeats until process A completes its task and releases the lock at which point Process B can now acquire the lock and start working. Do you see how wasteful this scenario was?

如果您不想看英文,那么看看我的总结:有人会说,在单核中会发生deadlock,这不准确。取决于使用何种调度算法,还有使用的spin_lock发生内核态还是用户态,如果使用CFS调度算法及在用户态进行spin_lock,此时会严重降低系统性能。有些调度算法比如EDF,则会造成dead_lock。
  那么上面还是没有提到
抢占非抢占的概念
,如果我们使用spin_lock在内核态,比如在驱动编写中Spin_lock如果针对的是非抢占的内核,而系统又是单核的话,这就是灾难!
  第三个问题:那么中断处理函数的执行实在内核态或者用户态呢? 这个答案是百分之百在内核态,并且在处理完中断返回的时候,如果被中断的时候进程处于用户态,则中断处理函数返回的时候会发生一次调度。

3. 主要API

#include <pthread.h>
int pthread_spin_init(pthread_spinlock_t *lock, int pshared);
int pthread_spin_destroy(pthread_spinlock_t *lock);
Both return: 0 if OK, error number on failure

int pthread_spin_lock(pthread_spinlock_t *lock);
int pthread_spin_trylock(pthread_spinlock_t *lock);
int pthread_spin_unlock(pthread_spinlock_t *lock);
All return: 0 if OK, error number on failure

简单阐述下pthread_spin_lock的用法:

  • pthread_spin_init初始化一个锁,pthread_spin_lock当前线程加锁,如果未获得锁,将一直忙等待,此时该线程上的cpu一直处于忙等待。
  • 如果调度算法为CFS,那么spin_lock可能会降低系统性能。只有靠我们自己评估context switch和spin_lock的代价大小了。

NOTE: 以上步骤假设使用SMP架构处理器

4. 实验

如果我们简单的将我们上一篇使用的Mutex替换为spin_lock,看看会发生什么?

4.1 测试一:
[root@localhost ~]# diff -Naur 11_4.c 11_6.c
--- 11_4.c      2018-02-09 17:48:17.463201599 +0800
+++ 11_6.c      2018-02-09 20:09:33.666472377 +0800
@@ -13,7 +13,7 @@
 };
 
 struct foo *fh[NHASH];
-pthread_mutex_t hashlock = PTHREAD_MUTEX_INITIALIZER;
+pthread_spinlock_t spin;
 pthread_mutex_t hashr_mutex = PTHREAD_MUTEX_INITIALIZER;
 pthread_cond_t hashr_cond = PTHREAD_COND_INITIALIZER;
 
@@ -28,12 +28,12 @@
         if ((fp = malloc(sizeof(struct foo))) != NULL)
         {
                 fp->f_id = id;
-                foo_printf(fp);
                 idx = HASH(id);
-                pthread_mutex_lock(&hashlock);
+                pthread_spin_lock(&spin);
                 fp->f_next = fh[idx];
                 fh[idx] = fp;
-                pthread_mutex_unlock(&hashlock);
+                foo_printf(fp);
+                pthread_spin_unlock(&spin);
         }
         return(fp);
 }
@@ -41,7 +41,7 @@
 struct foo * foo_find(int id)
 {
         struct foo * fp;
-        pthread_mutex_lock(&hashlock);
+        pthread_spin_lock(&spin);
         for (fp = fh[HASH(id)]; fp != NULL; fp = fp->f_next)
         {
                 if (fp->f_id == id)
@@ -49,7 +49,7 @@
                         break;
                 }
         }
-        pthread_mutex_unlock(&hashlock);
+        pthread_spin_unlock(&spin);
         return(fp);
 }
 
@@ -57,18 +57,18 @@
 {
         struct foo * fp;
        struct foo * fp1;
-        pthread_mutex_lock(&hashlock);
+        pthread_spin_lock(&spin);
         for (fp = fh[HASH(id)]; fp != NULL; fp = fp->f_next)
         {
                 if (fp->f_id == id)
                 {
-                        if( fp == fh[HASH(id)])
+                        if(fp == fh[HASH(id)])
                         {
                                 fh[HASH(id)] = fp->f_next;
                         }
                         else
                         {
-                            fp1=fh[HASH(id)];
+                                fp1=fh[HASH(id)];
                                 while (fp1->f_next != fp)
                                         fp1 = fp1->f_next;
                                 fp1->f_next = fp->f_next;
@@ -76,7 +76,7 @@
                         break;
                 }
         }
-        pthread_mutex_unlock(&hashlock);
+        pthread_spin_unlock(&spin);
         if(fp == NULL)
                 return 1;
         free(fp);
@@ -124,8 +124,9 @@
         int done[3]={4,4,4};
         pthread_t tid;
         char i=0;
+       pthread_spin_init(&spin,PTHREAD_PROCESS_PRIVATE);
         for( num=0;num<NHASH;num++)
-        {                                                                                                                                                                                                             
+        {
                 err = pthread_create(&tid, NULL, thr_fn,(void *)(num*NHASH));
                 if (err != 0)
                         errx(1, "can’t create thread:%d\n",num);

结果如下:

[root@localhost ~]# ./11_6
thread 140351228299008, foo_id:0
thread 140351219906304, foo_id:3
thread 140351236589312, foo_id:0
thread 140351142622976, foo_id:6
thread 140351236589312, foo_id:3
thread 140351236589312, foo_id:6

正常完成了测试,发现竟然简单的替换就成功了。但是需要进行下简单的时间测试,增加测试时间的代码(为了篇幅,不贴出来)并与上个使用mutex的实验对比,结果如下:

//spin_lock版本
[root@localhost ~]# ./11_6_1                           
thread 140228922906368, foo_id:0
thread 140228914513664, foo_id:3
thread 140228931196672, foo_id:0
thread 140228906120960, foo_id:6
thread 140228931196672, foo_id:3
thread 140228931196672, foo_id:6
run time:3769

//mutex版本
[root@localhost ~]# ./11_6_2
thread 140255847200512, foo_id:0
thread 140255830415104, foo_id:6
thread 140255838807808, foo_id:3
thread 140255855490816, foo_id:0
thread 140255855490816, foo_id:3
thread 140255855490816, foo_id:6
run time:2139

Spin_lock版本比mutex版本运行的时间还要长,也就是说spin_lock不适合在这样的场合!比较笼统的解释这样的结果就是spin_lock自身进行忙等待的消耗大于了mutex所引发的线程调度的上下文切换的开销,说白了就是spin所保护的代码段所进行的操作比较长。

4.2 测试二:
[root@localhost ~]# diff -Naur 11_6.c 11_6_3.c
--- 11_6.c      2018-02-09 20:09:33.666472377 +0800
+++ 11_6_3.c    2018-02-09 20:12:12.235815697 +0800
@@ -33,7 +33,7 @@
                 fp->f_next = fh[idx];
                 fh[idx] = fp;
                 foo_printf(fp);
-                pthread_spin_unlock(&spin);
+               // pthread_spin_unlock(&spin); 刻意不释放锁
         }
         return(fp);
 }

结果:

[root@localhost ~]# ./11_6_3                                                      
thread 139762245465856, foo_id:0
//程序卡死在这里

这里写图片描述
  
  3个核心deadlock,因为有一个线程调用了foo_alloc,首先获得了锁,然后又会调用pthread_cond_wait从而自己sleep了。此时其他的两个线程就会deadlock,然而主线程当其调用foo_find时也会deadlock。所以top命令的结果如上所示。同时从侧面我们也发现Linux任务调度的单位是线程,在Linux线程本质上作为进程处理,更具体详细的信息需要看相关内核调度的知识了。

5. 留在最后

接触了spin_lock,笔者才发现自己的内功太浅,以后会再把内核相关的书好好看看,因为有些问题是基本功!笔者注意到驱动编程和在应用层编程区别有些明显啊,在使用POSIX接口API进行编程的时候,不应该考虑到内核层面,所以我得出一个结论:进行POSIX编程时,忽略内核层面特征,只考虑API本身的特征,举例:多线程就考虑多个执行流同时执行,别瞎想什么调度啊,内核态用户态什么哒~

Vector CANape的使用记录 开门见山,今天想和大家分享下CANape使用记录,分享原因是近日在分析一个客户现场软件问题时,需要用到CANape来实时的监测ECU中的变量,因为之前对CANape的认知比较浅薄,觉得标定工程师使用他就足够了,但是这次的经历让我觉得需要写点东西来记录自己学习并使用他的过程。 相信大家能够在网上找到很多关于如何使用CANape的文章,从新建Project到后面的数据的观测、保存以及回放等等。我个人也是这么学过来的,所以我不打算从那些方面着手去描述如何使用她,而是根据我的真实使用过程以及问题的抛出到如何解决来 阅读详情

相关推荐

指导初学者使用Anaconda运行GitHub上One - DM项目的步骤

指导初学者使用Anaconda运行GitHub上One - DM项目的步骤。

AI的内部世界的博客 1485

linux多线程同步概览

linux多线程同步概览临界区互斥锁 mutex基本函数pthread_mutex_destroy 何时调用?互斥锁类型?互斥量和自旋锁的区别条件变量 condition variable基本函数流程读写锁 reader-writer lock单读多写的场景自旋锁 spin lock初始化自旋锁获得一个自旋锁尝试获取一个自旋锁释放(解锁)一个自旋锁销毁一个自旋锁信号量 semphoreunique_lock成员函数thread local__thread 临界区 当两个线程竞争同一资源时,如果对资源的访

杰特JET的博客 395

Ubuntu本地部署CodeX编程助手:CLI配置全指南

本地AI编程助手是当前开发者关注的核心技术趋势,指在不依赖云端API、保障代码隐私前提下,于本地环境运行具备代码理解、多语言补全与知识库检索能力的智能辅助工具。其技术原理涉及模型加载、API网关编排、向量数据库集成及系统级资源调度,关键价值在于可控性、低延迟与合规性。典型应用场景包括企业内网DevOps提效、边缘设备嵌入式开发支持,以及敏感代码场景下的离线编程增强。本文聚焦Ubuntu系统下基于CLI的手动配置路径,深入解析Ollama服务注册、Node.js版本锁定、API Key环境隔离及Qwen2.5

weixin_26804345的博客 605

Linux应用 线程同步之自旋锁

本文讲解了Linux线程同步中使用的自旋锁的定义和应用场景,列举了编程中常用的接口,并编写测试用例进行测试。

cesheng3410的博客 2110

从M350 RTK到E-Port:解锁大疆无人机多负载协同与PSDK V3开发新范式

本文深入解析了大疆M350 RTK无人机搭载的E-Port智能接口与全新的PSDK V3开发套件,如何共同实现多负载协同作业的范式转变。E-Port集成了供电与高速数据总线,而PSDK V3通过统一的设备模型与服务机制,大幅降低了第三方负载的开发门槛与集成复杂度,使构建如智能巡检等复杂空中作业系统变得更加高效和标准化。

3c4x5z6v7b的博客 167

ADS仿真功率放大器实例学习笔记

ADS仿真功率放大器实例学习笔记

qq_36521926的博客 1万+

linux多线程:自旋锁

1、概述 自旋锁是 SMP 架构中的一种 low-level 的同步机制。 当线程A想要获取一把自旋锁而该锁又被其它线程锁持有时,线程A会在一个循环中自旋以检测锁是不是已经可用了。 对于使用自选锁需要注意: 由于自旋时不释放CPU,因而持有自旋锁的线程应该尽快释放自旋锁,否则等待该自旋锁的线程会一直在那里自旋,这就会浪费CPU时间。 持有自旋锁的线程在sleep之前应该释放自旋锁以便其它线...

2998

从零开始:QNX SDP 8.0开发环境搭建与实战入门

本文详细介绍了如何从零开始搭建QNX SDP 8.0开发环境并进行实战入门。内容涵盖许可证获取、环境安装、命令行与IDE工具使用、BSP构建、系统镜像生成,以及编写、编译和运行第一个QNX程序的全过程。旨在帮助嵌入式开发者,特别是汽车电子和工业控制领域的工程师,快速掌握这一实时操作系统(RTOS)的开发基础。

weixin_29163857的博客 646

pthread_spin_lock 自旋锁

锁机制(lock) 是多线程编程中最常用的同步机制,用来对多线程间共享的临界区(Critical Section) 进行保护。 Pthreads提供了多种锁机制,常见的有: 1) Mutex(互斥量):pthread_mutex_*** 2) Spin lock(自旋锁):pthread_spin_*** 3) Condition Variable(条件变量):pthread_con_**

JoJo-追求卓越~ 1万+

C/C++ 计算程序运行的时间

C/C++计算程序执行时间的方法,精度依次增加,推荐度也依次增加 1.#include <time.h> clock_t start, finish; double process_interval ; start=clock(); process(); //要计时的程序 finish=clock(); process_interval =(double)(finish-star...

stu_shanghui的博客 1021

如何玩转腾讯云轻量级服务器(新手向)

如何玩转腾讯云轻量级服务器(新手向) ​ 相信不少同学都想将自己的服务器部署到云服务器,让别人通过自己的域名就可以访问到自己的项目,而腾讯云轻量级服务器作为一个小型的应用,支持域名解析和可视化运维等。比较适合新手入门 ​ 本文服务器操作系统为Centos7 一. 购买以及基本配置 1.购买方式 ​ 本文主要面向新手,毕竟一般只有新手才会购买轻量级服务器。所以可以选择购买一年的来学习,以后再根据需要换,前提提示(轻量级服务器没有安全组的,开放端口直接开启防火墙里的即可) ​ 购买连接 购买完成后点击控制

qq_46160687的博客 1万+

linux - spin lock实现分析

【代码】linux - spin lock实现分析。

天使之翼 866

在Android Jetpack Compose中实现夜间模式

Android基于Compose的深色主题实现

虎哥LoveDroid 1243

spin_lock_irqsave 的中断上下文保护

要理解 spin_lock_irqsave,需要结合中断的运行机制以及可能出现的问题来详细说明。假设一个共享资源probe_onespin_lockspin_lock会在加锁前,并保存当前中断状态。

a740692847的博客 1441

SAP B1中文培訓教材_SDK

公司内部培训资料,对开发工具 ,DIAPI, UIAPI,Add-ON有详细解说

霍尼韦尔SoftMaster使用说明

霍尼韦尔SoftMaster使用说明

Linux内核之自旋锁:自旋锁初始化之spin_lock_init用法实例(四十五)

本篇目的:Linux内核之自旋锁:spin_lock_init用法实例Linux内核是一个开源的类UNIX操作系统内核,被广泛用于各种计算机系统。在Linux内核中,同步机制是确保多线程程序正确性的关键部分。是Linux内核中用于初始化自旋锁的一个函数,它用于保护内核中的临界区,防止多个线程同时访问共享资源。自旋锁(spinlock)是一种锁,当一个线程尝试获取一个已被其他线程获取的锁时,该线程将在一个循环中不断地检查锁是否已经可用。这个过程被称为“自旋”。

Android系统攻城狮 2736

lwip-2.0.3

lwip是瑞典计算机科学院(SICS)的Adam Dunkels 开发的一个小型开源的TCP/IP协议栈。实现的重点是在保持TCP协议主要功能的基础上减少对RAM 的占用。

性能对比pthread mutex/spin lock/spin lock delay

代码 代码如下 main.cc // // Created by 孙川 on 2018/8/13. // #include &amp;amp;lt;iostream&amp;amp;gt; #include &amp;amp;lt;pthread.h&amp;amp;gt; #include &amp;quot;spin.h&amp;quot; using std::cout; using std::endl; pthread_mute

sunashe的个人随笔 743

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

Linux内核之互斥锁mutex_init和自旋锁spin_lock区别及用法实例(四十六)

本篇目的:Linux内核之互斥锁mutex_init和自旋锁spin_lock区别及用法实例在Linux内核中,mutex_init和spin_lock是两种常用的同步机制,用于在多线程或多处理器环境中保护共享资源,防止并发访问造成的数据不一致问题。mutex_init用于初始化一个互斥锁(mutex),它是一种睡眠锁。当一个线程尝试获取一个已经被其他线程持有的互斥锁时,该线程会被阻塞,进入睡眠状态,直到互斥锁被释放。互斥锁适用于那些可能造成较长时间阻塞的场景,因为线程睡眠状态不会消耗CPU资源。

Android系统攻城狮 2806

终于彻底搞清楚了 MySQL spin-lock 之一次CPU问题定位过程总结

os_rmb;// 加锁失败,调用ut_delayi++;//暂停当前正在执行的线程对象(及放弃当前拥有的cup资源)} else {//MySQL关于spin lock的部分代码。如下代码可以看到MySQL默认作了30次(innodb_sync_spin_loops=30)mutex检查后,才放弃占用CPU资源。//暂停当前正在执行的线程对象(及放弃当前拥有的cup资源)注:上面代码,线程中的yield()方法说明。

m0_60147147的博客 873

spin_lock相关

spin_lock - 自旋锁 编程时, 经常需要考虑的问题是同步问题。 谁和谁之间同步呢?? 看你的关键代码段和共享数据区的访问/读写者。 有可能会很多, 很乱... 比如: 线程和线程, 线程和中断, 中断和中断, 此核和彼核... 应用, 内核等都有很多锁, 互斥, 原子等机制... 内核中, 比如 1. 原子变量 2. 自旋锁 spin_lock 3. 互...

River的专栏 339

spin_lock_irqsave

防止自旋锁阶段被中断

weixin_41176474的博客 442

Linux内核同步方法——自旋锁(spin lock)

自旋锁    Linux的的内核最常见的锁是自旋锁。自旋锁最多只能被一个可执行线程持有。如果一个执行线程试图获得一个被已经持有(争用)的自旋锁,那么该线程就会一直进行忙循环-旋转-等待锁重新可用要是锁未被争用,请求锁的执行线程就可以立即得到它,继续执行。    在任意时间,自旋锁都可以防止多于一个的执行线程同时进入临界区。同一个锁可以用在多个位置,例如,对于给定数据的所有访问都可以得到保护和同步。...

hhhanpan的博客 3万+

spin_lock 自旋锁 和 mutex_lock 互斥锁的区别

spin_lock 自旋锁 和 mutex_lock 互斥锁的区别内核锁的讨论:为什么需要内核锁?多核处理器下,会存在多个进程处于内核态的情况,而在内核态下,进程是可以访问所有内核数据的,因此要对共享数据进行保护,即互斥处理有哪些内核锁机制? (1)原子操作 atomic_t数据类型,atomic_inc(atomic_t *v)将v加1 原子操作比普通操作效率要低,因此必要时才使用,且不能与普通

青山师 2109

spin_lock 与mutex_lock区别,semephore与mutex 区别

spin_lock 与mutex_lock区别,semephore与mutex 区别

flying_zhayg的专栏 726

spin_lock & mutex_lock的区别? .

本文由该问题引入到内核锁的讨论,归纳如下 为什么需要内核锁? 多核处理器下,会存在多个进程处于内核态的情况,而在内核态下,进程是可以访问所有内核数据的,因此要对共享数据进行保护,即互斥处理 有哪些内核锁机制? (1)原子操作 atomic_t数据类型,atomic_inc(atomic_t *v)将v加1 原子操作比普通操作效率要低,因此必要时才使用,且不能与普通操作混

Wilsonboliu的专栏 2万+

C++的自旋锁(spin_lock)实现:使用atomic_flag类型

使用原子类型atomic_flag来实现自旋锁

JunJie的个人博客 5896

Mutex VS spin lock

锁机制(lock) 是多线程编程中最常用的同步机制,用来对多线程间共享的临界区(Critical Section) 进行保护。 Pthreads提供了多种锁机制,常见的有: 1) Mutex(互斥量):pthread_mutex_*** 2) Spin lock(自旋锁):pthread_spin_*** 3) Condition Variable(条件变量):pthread_con_**

2111
上一篇: 重新开始,本博客声明
下一篇: 多线程之问题的解决及使用GDB调试多线程多进程的手段(九)
LoveStackover
博客等级 码龄9年 14粉丝 57原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值