内核同步方法及其比较

三代微内核及其IPC比较 1. 微内核简要发展历程: 操作系统微内核技术起始于20世纪80年代,随着微内核思想的进一步发展完善,目前为止可以分为三代。 1.1 第一代微内核: 第一代微内核的主要代表是Mach,Mach以IPC是作为所有系统服务与内核交换数据的基础机制,充分运用IPC、虚拟内存、多进程等特性将冗余的系统服务移出内核作为进程运行。Mach的价值在于它的抽象、可扩展性和灵活性。特别地,Mach提供了 基于对象的api,使用通信通道(例如,端口)作为对象引用 高度并行执行,包括预先调度的线程和对SMP 阅读详情

前些天在处理一个bug时发现了一些问题。


static void headmicbias_power_on(struct device *dev, int on)
{
unsigned long spin_lock_flags;
static int current_power_state = 0;
struct sprd_headset *ht = &headset;

spin_lock_irqsave(&headmic_bias_lock, spin_lock_flags);
if (1 == on) {
if (0 == current_power_state) {
if(NULL != ht->platform_data->external_headmicbias_power_on)
ht->platform_data->external_headmicbias_power_on(1);
sprd_headset_headmic_bias_control(dev, 1);
current_power_state = 1;
}
} else {
if (1 == current_power_state) {
if(NULL != ht->platform_data->external_headmicbias_power_on)
ht->platform_data->external_headmicbias_power_on(0);
sprd_headset_headmic_bias_control(dev, 0);
current_power_state = 0;
}
}
spin_unlock_irqrestore(&headmic_bias_lock, spin_lock_flags);

return;
}




以上函数中用自旋锁做了保护,但是出现了死锁现象。死锁时的调用栈如下:

-000|mspin_lock(
    |    lock = 0xCF57D34C,
    |    node = 0xCC5C5E44)
    |  size = 4
    |  ptr = 0xCF57D34C
    |  x = 3428605508
    |
-001|__mutex_lock_slowpath(
    |    lock_count = 0xCF57D338)
    |  lock = 0xCF57D338
    |  state = 2
    |  lock = 0xCF57D338 -> (
    |    count = (counter = -1),
    |    wait_lock = (rlock = (raw_lock = (slock = 0, tickets = (owner = 0, next
    |    wait_list = (next = 0xCF57D340, prev = 0xCF57D340),
    |    owner = 0x0,
    |    spin_mlock = 0x0)
    |  task = 0xCBFD4980
    |  waiter = (list = (next = 0x0, prev = 0x0), task = 0xCEFE0000)
    |  lock = 0xCF57D338
    |  node = (next = 0x0, locked = 0)
    |  flag = 1
    |
    |
-002|mutex_lock(                                                               //在调用regulator_enable的函数中又有一个互斥锁,而互斥锁是允许休眠的。
    |    lock = 0xCF57D338)
    |  count = 0xCF57D338
    |  i = 1
    |  v = 0xCF57D338
    |  lock = 0xCF57D338
    |  sp = 3428605552
    |
    |

-003|regulator_enable(
    |  ?)
    |  rdev = 0xCF57D300
    |  rdev = 0xCF57D300
    |
    |
-004|regulator_enable(
    |  ?)
    |  rdev = 0xCF57E140
    |
    |
-005|regulator_enable(
    |  ?)
    |  rdev = 0xCF5F3900
    |
    |
-006|sprd_headset_headmic_bias_control.isra.11(
    |  ?,
    |  ?)
    |
    |
-007|headmicbias_power_on.isra.12(                                //进入该函数后拿到一个自旋锁
    |    on = 1,
    |  ?)
    |  spin_lock_flags = 537854227
    |  current_power_state = 0
    |
    |

-008|headset_detect_work_func(
    |  ?)
    |  pdata = 0xCEFC7B00
    |  __func__ = (104, 101, 97, 100, 115, 101, 116, 95, 100, 101, 116, 101, 99,
    |
    |
-009|process_one_work(
    |    worker = 0xCB504780,
    |    work = 0xC08916C4)
    |  pwq = 0xCEFE0000
    |  pool = 0xCF4042C0
    |  cpu_intensive = FALSE
    |  work_color = 0
    |  __warned = FALSE
    |  __warned = FALSE
    |  __warned = FALSE
    |  val = 3230209732
    |  n = 0xCB504780
    |  work = 0xC08916C4
    |  __warned = FALSE
    |  __warned = FALSE
    |  lock = 0xCF4042C0
    |  work = 0xC08916C4
    |  worker = 0xCB504780
    |  sp = 3428605712
    |  __warned = FALSE
    |  __warned = FALSE
    |  __warned = FALSE
    |
    |
-010|worker_thread(
    |    __worker = 0xCB504780)
    |  worker = 0xCB504780
    |  pool = 0xCF4042C0
    |  worker = 0xCB504780
    |  __warned = FALSE
    |  __warned = FALSE
    |  __warned = FALSE
    |  __warned = FALSE
    |  __warned = FALSE
    |  lock = 0xCF4042C0
    |  __warned = FALSE
    |  __warned = FALSE
    |  __warned = FALSE
    |  __warned = FALSE
    |  pool = 0xCF4042C0
    |  __warned = FALSE
    |  __warned = FALSE
    |  worker = 0xCB504780
    |  pool = 0xCF4042C0
    |  oflags = 137
    |  __warned = FALSE
    |  __warned = FALSE
    |  __warned = FALSE
    |
    |
-011|kthread(
    |    _create = 0xC1AB9EB0)
    |  create = 0xC1AB9EB0
    |  threadfn = 0xC0051040
    |  data = 0xCB504780
    |  self = (flags = 0, cpu = 327685, data = 0xCB504780, parked = (done = 0, w
    |  __key = ()
    |  __key = ()
    |  __key = ()
    |  __key = ()
    |  __key = ()
    |  nr = 1
    |
    |
-012|ret_from_fork(asm)
    |
    |
-->|exception
---|end of frame


N _  R0   CF57D34C  R8          0  SP> 00000001
Z _  R1   CC5C5E44  R9          0  +04 00000000
C C  R2   CC5C5E44  R10         0  +08 00000000
V _  R3          0  R11        89  +0C CEFE0000
Q _  R4   CF57D338  R12         0  +10 CF57EAC0
     R5   CBFD4980  R13  CC5C5E40  +14 CF57D338
0 _  R6   CF57D34C  R14  C0587174  +18 00000000
1 _  R7   CC5C4000  PC   C0058864  +1C 200F0113
2 _  SPSR 600F0113  CPSR 200F0193  +20 CF57D338
3 _                                +24 CEFE0000
4 _  USR:           FIQ:           +28 00000000
     R8          0  R8   F42CAA39  +2C C0587368
     R9          0  R9   D4A5F9B3  +30 CF57D300
I I  R10         0  R10  DBFAB7D9  +34 C0243794
F _  R11        89  R11  6E7DE52B  +38 00000000
     R12         0  R12  F4B05BA7  +3C CF57E140
T _  R13  B2664C38  R13  AA0ACFD1  +40 00000001
J _  R14  B6EB5023  R14  DC2FBFFB  +44 200F0113
svc                 SPSR 960CC314  +48 C08A4F99
sec                                +4C CEFE0000
     SVC:           IRQ:           +50 00000000
A A  R13  CC5C5E40  R13  C08BB380  +54 C02437A8
E _  R14  C0587174  R14  C000F000  +58 00000000
     SPSR 600F0113  SPSR 600F0193  +5C CF5F3900
0 G                                +60 00000001
1 G  UND:           ABT:           +64 200F0113
2 G  R13  C08BB398  R13  C08BB38C  +68 C08A4F99
3 G  R14  C000F220  R14  C000F180  +6C CEFE0000
     SPSR A0070093  SPSR 600F0193  +70 00000000
                                   +74 C02437A8
     MON:           HYP:           +78 00000001
     R13  BCC5850B  R13  BCC5850B  +7C C096C140
     R14  1C5087E7  ELR  970C5F65  +80 00000001
     SPSR 200CB402  SPSR 200CB402  +84 200F0113
                                   +88 C08A4F99
                                   +8C CEFE0000


________address|________0________4________8________C_0123456789ABCDEF
EZAHB:8F57D330| CF57D32C 00000000>00000001 00000000 ,.W.............
EZAHB:8F57D340| CF57D340 CF57D340 00000000 00000000 @.W.@.W.........
EZAHB:8F57D350| 00000000 00000000 C089A660 CF5CEDC0 ........`.....\.
EZAHB:8F57D360| CF5D7100 CF57E664 CF57EB24 CF5D7E00 .q].d.W.$.W..~].
EZAHB:8F57D370| CF4D0E00 C0887E78 CF5D6960 00000003 ..M.x~..`i].....

//========================================================================


以上代码就是一个典型自选所包裹互斥锁的例子。因为互斥锁允许休眠,所以可以理解为在自旋锁所管辖的临界区发生了休眠。

我们知道,持有自旋锁的代码段要尽量简短且不能有睡眠动作。但是,如果我们做一个不合适的实验:让一个持有自旋锁的代码段进入休眠状态,在此期间如果没有其他进程请求该锁,则不会发生问题,如果请求该锁的进程运行(自旋)在另一个cpu,这也不会出事。但是假如请求该锁的进程和持有该锁的进程运行在同一个cpu,则会出现死锁。

更重要的原因是自旋锁自旋时是被设设为禁止抢占的,所以,如果一个如果进入自旋状态时,在单核情况下就无法再进行调度。自然死锁了!


上述代码中用自旋锁包裹了互斥锁,在大部分情况下都没有发生死锁,为什么只在小概率下发生死锁呢?

原因是中断被屏蔽了,spin_lock_irqsave调用会屏蔽本cpu上的中断。如果接下来的互斥锁的临界区内再发生了休眠,这就会导致任务调度停止,因为没有中断了,而任务调度的基础就是时钟中断!大部分时候,临界区内的代码都没有发生休眠,所以我们看到的是小概率的死锁现象。另外再注意到一点,就是这个死锁发生在休眠唤醒流程中,因为这个过程是单核运行的。在正常的多核条件下,也不容易发生死锁,因为其他cpu上的调度还可以正常进行。



进程死锁:

1. 两个进程互相等待对方持有的互斥锁时会导致二者都进入休眠状态,永远得不到执行。发生死锁。

2. 一个进程第二次申请一个已经被自己持有的互斥锁时会导致自己进入休眠状态且无法醒过来,发生死锁。



以下内容转自:http://funexploit.github.io/sources/kernel_sync.html

原子操作

包括32位、64位原子整数操作和原子位操作

自旋锁

内核中最常见的锁机制就是自旋锁。

自旋锁的目的是在短期内进行轻量级加锁,因为自旋锁不应该被长时间持有。

Linux内核中实现的自旋锁不能递归使用,尝试获取自己已经持有的自旋锁,会导致被自己锁死。

自旋锁可以在不能休眠的代码中使用,比如中断处理程序。而且拥有自旋锁的代码必须是原子的,绝对不能休眠,否则其它线程试图获得同一个锁,可能会导致死锁。

自旋锁的操作

void spin_lock_init(spinlock_t *lock)

void spin_lock(spinlock_t *lock)
void spin_unlock(spinlock_t *lock)


void spin_lock_irq(spinlock_t *lock)
void spin_unlock_irq(spinlock_t *lock)

void spin_lock_irqsave(spinlock_t *lock)
void spin_unlock_irqrestore(spinlock_t *lock)

int spin_trylock(spinlock_t *lock)
int spin_is_locked(spinlock_t *lock)

信号量

信号量是一种休眠锁,一个任务在获取一个已经被占用的信号量时,信号量会将其推进一个等待队列,然后让其休眠。当信号量被释放时,原先休眠的任务会被唤醒。

只能在进程上下文中获取信号量,不能在中断上下文中获取信号量,因为中断上下文中进程不能被调度成休眠状态。

自旋锁和信号量不能同时占有,因为在等待信号量的时候进城可能被调度成休眠状态,而在持有自旋锁时是不允许休眠的。

信号量不同于自旋锁,它不会禁止内核抢占,所以持有信号量的代码可以被抢占。

如果代码可以休眠,则只能使用信号量,不能自旋锁。 如果锁可能会被占用较长时间,使用信号量,否则使用自旋锁。

信号量一般情况下应该使用可中断的版本。

信号量的操作

void sema_init(struct semaphore *sem, int val)
extern void down(struct semaphore *sem);
extern int __must_check down_interruptible(struct semaphore *sem);
extern int __must_check down_killable(struct semaphore *sem);
extern int __must_check down_trylock(struct semaphore *sem);
extern int __must_check down_timeout(struct semaphore *sem, long jiffies);
extern void up(struct semaphore *sem);

互斥体

互斥体是指任何可以休眠的强制互斥锁。互斥体是一种互斥信号。

互斥体使用上相对于信号量更加严格。最重要的一条是:上锁者必须负责解锁(),当持有互斥体锁时进程不能退出。另外,同信号量一样,互斥体不能在中断内部或者中断的下半部中使用。

互斥体的操作

struct mutex
void mutex_init(struct mutex *)
void mutex_lock(struct mutex *)
void mutex_unlock(struct mutex *)
int mutex_trylock(struct mutex *)
int mutex_is_locked(struct mutex *)



以下内容转自:http://blog.youkuaiyun.com/vividonly/article/details/6594195

最近在内核频繁使用了自旋锁,自旋锁如果使用不当,极易引起死锁,在此总结一下。


自旋锁是一个互斥设备,它只有两个值:“锁定”和“解锁”。它通常实现为某个整数值中的某个位。希望获得某个特定锁得代码测试相关的位。如果锁可用,则“锁定”被设置,而代码继续进入临界区;相反,如果锁被其他人获得,则代码进入忙循环(而不是休眠,这也是自旋锁和一般锁的区别)并重复检查这个锁,直到该锁可用为止,这就是自旋的过程。“测试并设置位”的操作必须是原子的,这样,即使多个线程在给定时间自旋,也只有一个线程可获得该锁。


自旋锁最初是为了在多处理器系统(SMP)使用而设计的,但是只要考虑到并发问题,单处理器在运行可抢占内核时其行为就类似于SMP。因此,自旋锁对于SMP和单处理器可抢占内核都适用。可以想象,当一个处理器处于自旋状态时,它做不了任何有用的工作,因此自旋锁对于单处理器不可抢占内核没有意义,实际上,非抢占式的单处理器系统上自旋锁被实现为空操作,不做任何事情。


自旋锁有几个重要的特性:1、被自旋锁保护的临界区代码执行时不能进入休眠。2、被自旋锁保护的临界区代码执行时是不能被被其他中断中断。3、被自旋锁保护的临界区代码执行时,内核不能被抢占。从这几个特性可以归纳出一个共性:被自旋锁保护的临界区代码执行时,它不能因为任何原因放弃处理器。


考虑上面第一种情况,想象你的内核代码请求到一个自旋锁并且在它的临界区里做它的事情,在中间某处,你的代码失去了处理器。或许它已调用了一个函数(copy_from_user,假设)使进程进入睡眠。也或许,内核抢占发威,一个更高优先级的进程将你的代码推到了一边。此时,正好某个别的线程想获取同一个锁,如果这个线程运行在和你的内核代码不同的处理器上(幸运的情况),那么它可能要自旋等待一段时间(可能很长),当你的代码从休眠中唤醒或者重新得到处理器并释放锁,它就能得到锁。而最坏的情况是,那个想获取锁得线程刚好和你的代码运行在同一个处理器上,这时它将一直持有CPU进行自旋操作,而你的代码是永远不可能有任何机会来获得CPU释放这个锁了,这就是悲催的死锁。


考虑上面第二种情况,和上面第一种情况类似。假设我们的驱动程序正在运行,并且已经获取了一个自旋锁,这个锁控制着对设备的访问。在拥有这个锁得时候,设备产生了一个中断,它导致中断处理例程被调用,而中断处理例程在访问设备之前,也要获得这个锁。当中断处理例程和我们的驱动程序代码在同一个处理器上运行时,由于中断处理例程持有CPU不断自旋,我们的代码将得不到机会释放锁,这也将导致死锁。


因此,如果我们有一个自旋锁,它可以被运行在(硬件或软件)中断上下文中的代码获得,则必须使用某个禁用中断的spin_lock形式的锁来禁用本地中断(注意,只是禁用本地CPU的中断,不能禁用别的处理器的中断),使用其他的锁定函数迟早会导致系统死锁(导致死锁的时间可能不定,但是发生上述死锁情况的概率肯定是有的,看处理器怎么调度了)。如果我们不会在硬中断处理例程中访问自旋锁,但可能在软中断(例如,以tasklet的形式运行的代码)中访问,则应该使用spin_lock_bh,以便在安全避免死锁的同时还能服务硬件中断。


补充:


锁定一个自旋锁的函数有四个:


void spin_lock(spinlock_t *lock);      


最基本得自旋锁函数,它不失效本地中断。


void spin_lock_irqsave(spinlock_t *lock, unsigned long flags);


在获得自旋锁之前禁用硬中断(只在本地处理器上),而先前的中断状态保存在flags中


void spin_lockirq(spinlock_t *lock);


在获得自旋锁之前禁用硬中断(只在本地处理器上),不保存中断状态


void spin_lock_bh(spinlock_t *lock);


在获得锁前禁用软中断,保持硬中断打开状态



还可以参考:http://blog.chinaunix.net/uid-26990992-id-3264808.html

http://www.embedu.org/Column/Column25.htm






linux内核学习12:Linux内核中的同步机制,进程的同步同步机制,线程的同步机制 1. 什么是同步,为什么要同步,什么是互斥 1.1 同步和互斥 同步:用于实现控制多个进程按照一定的规则或顺序访问某些系统资源的机制。 互斥:实现控制某些系统资源在任意时刻只能允许一个进程访问的机制。互斥是同步机制中的一种特殊情况。 1.2 为什么要同步     在操作系统引入了进程概念,进程成为调度实体后,系统就具备了并发执行多个进程的能力,但也导致了系统中各个进程之间的资源竞争和共享。另外,由于中断、异常机制的引入,以及内核态抢占都导致了这些内核执行路径(进程)以交错的方式运行。对于这些交错路径执行 阅读详情

相关推荐

Linux内核同步机制的自旋锁原理

本文主要介绍了linux内核自旋锁是如何工作的。

记录一次cephfs内核客户端死锁问题定位过程

记录一次cephfs内核客户端死锁问题定位过程 原文地址:https://zhuanlan.zhihu.com/p/375464867 一、 问题背景 Ceph是一款开源分布式存储系统,其具有丰富的功能和高可靠、高扩展性,并且提供统一存储服务,可以同时提供文件、对象、块服务。随着集群规模和业务量的增大,在使用文件的过程中遇到文件系统内核客户端死锁的问题,本文将详细介绍问题的定位过程和解决方案。 二、架构介绍 为了更好的阐述问题,先简单的介绍一下文件系统的整体架构,架构如下 图1 系统架构图 从图中可以看出

HHFQ的博客 2461

Unreal Engine鸿蒙移植实战:环境配置、构建流程与性能优化指南

游戏引擎移植是跨平台开发中的关键技术环节,其核心原理在于通过适配目标操作系统的底层接口和工具链,实现同一套代码在不同硬件和软件环境下的高效运行。这项技术的价值在于最大化代码复用率,降低多平台维护成本,并能让应用快速触达新兴生态系统的用户。在移动游戏和XR应用领域,随着鸿蒙HarmonyOS生态的快速发展,将成熟的商业引擎如Unreal Engine迁移至此平台,成为开发者探索新市场机会的重要路径。本文聚焦于Unreal Engine项目向鸿蒙系统的移植实践,详细解析了从环境搭建、源码适配到构建打包的全链路流

weixin_29011395的博客 411

内核同步方法

1.原子操作 原子整数操作 描述 ATOMIC_INIT(int i)   在声明一个atomic_t变量时,将它初始化为i int atomic_read(atomic_t *v)   原子地读取整数变量v void atomic_set(atomic_t *v, int i)  

theone 406

手把手教你搞定JBI投稿:从Statement of Significance到Declaration Statement的保姆级避坑指南

本文提供了一份详细的JBI投稿指南,重点解析Statement of Significance和Declaration of Interests的撰写技巧,帮助研究者避开常见格式陷阱。通过实战案例和检查清单,确保投稿符合JBI的学术严谨性和临床转化价值要求,提升稿件通过率。

weixin_29278805的博客 626

本地大模型部署实战:LM Studio与Ollama的易用性与性能深度评测

本文对两款主流本地大模型部署工具LM Studio和Ollama进行了深度评测。LM Studio凭借图形化界面和内置模型库,为新手提供了开箱即用的便捷体验,并支持OpenAI兼容API,易于生态集成。Ollama则以命令行驱动,轻量高效,凭借其原生API和Modelfile自定义能力,在自动化集成和性能方面表现突出。文章从易用性、模型生态、性能及扩展性多维度对比,帮助用户根据自身技术背景和使用场景做出最佳选择。

weixin_29039773的博客 531

linux内核之内核同步

当处理多处理器之间或硬件设备之间的同步问题时,有时需要在程序中以指定的顺序发出读内存和写内存的指令(指令的指令要按照特定的顺序)。但是为了提高效率,编译器或处理器可能会对程序指令重新排序(例如,处理器在执行指令期间,会在取指令和分派时,把表面上看上去无关的指令按照自认为最好的方式排序)。在读取数据前后,序列值都会被读取,如果读取的序列值相同,则说明读操作过程中没有新的数据写入。如果在中断处理程序中使用了自旋锁,那么,在其他地方获取锁之前(例如,可以被中断的进程上下文中),需要先禁止本地中断。

抱猫人的博客 844

Python实战:3步搞定视频去重,告别重复文件烦恼(附完整代码)

本文提供了一套基于Python的视频去重实战方案,通过三步流程(抽帧、生成内容指纹、相似度比对)高效识别重复视频文件。文章详细介绍了使用dHash算法生成视频指纹的核心原理,并提供了完整的代码实现,帮助用户快速构建自己的视频去重工具,告别重复文件管理烦恼。

weixin_29054245的博客 383

Linux内核设计与实现---内核同步方法

内核同步方法1 原子操作原子整数操作原子位操作2 自旋锁其他针对自旋锁的操作自旋锁和下半部3 读-写自旋锁4 信号量创建和初始化信号量使用信号量5 读-写信号量6 自旋锁和信号量7 完成变量8 BKL9 禁止抢占10 顺序和屏障 1 原子操作 原子整数操作 原子位操作 2 自旋锁 其他针对自旋锁的操作 自旋锁和下半部 3 读-写自旋锁 4 信号量 创建和初始化信号量 使用信号量 5 读-写信号量 6 自旋锁和信号量 7 完成变量 8 BKL 9 禁止抢占 10 顺序和屏障 ...

qq_41683305的博客 2553

Pytest教程:Pytest插件原理

Pytest的插件系统是其强大功能的核心,它允许用户和开发者扩展和定制测试框架的行为。要深入理解Pytest插件的原理,我们需要从Pytest的架构和设计模式开始,然后深入到底层源码。

旦莫的博客 638

OAuth2.0集成SpringSecurity加JWT实现单点登录

单点登录(Single sign on),英文名称缩写SSO,SSO的意思就是在多系统的环境中,登录单方系统,就可以在不用再次登录的情况下访问相关受信任的系统。也就是说只要登录一次单体系统就可以

Nicky's blog 9039

Linux内核原子函数,自旋锁,信号量了解(转)

一.为什么内核需要同步方法并发指的是多个执行单元同时,并行被执行,而并发的执行单元对共享资源(硬件资源和软件上的全局变量,静态变量等)的访问则很容易导致竞态。主要竞态发生如下:1.对称多处理器(SMP)多个CPU SMP是一种紧耦合,共享存储的系统模型,它的特点是多个CPU使用共同的系统总线,因此可访问共同的外设和存储器。 2.单CPU内进程与抢占它的进程Linux2.6内核支持抢占调度,一个进程

weixiuc的专栏 5772

ADS基础教程19 - 电磁仿真(EM)基本概念和实操

一、引言二、基本概念1.EM介绍2.Momentum介绍3.FEM介绍4.Substrate介绍三、创建Layout并进行Momentum仿真1.创建Layout2.添加Microtrip(微带线)3.添加Substrate4.Momentum仿真四、总结EM全称Electromagnetic,即electro(电)magnetic(磁)。ADS为设计和评估现代通信系统产品提供了电磁仿真工具(EM)。EM包括Momentumsimulator(动量仿真器)和FEM。

XZ_ZC的博客 1万+

内核同步的方法

在linux内核同步的介绍 一节我们介绍了同步的概念和那些数据和资源一般是需要防止并发的执行,同时就是需要同步的方法。 下面我们就介绍一下内核同步的方法:          同步就是避免并发和防止竞争条件。有关临界区的例子我就不举了,随便一本操作系统的书上都有。锁机制的提出也算解决了一些问题,我们待会再说,现在只要知道锁的使用是自愿的,非强制的。linux自身也提供了几种不同的锁机制,区别主

工匠 827

uniapp H5刷新页面后返回按钮失效问题完美解决方案

这个问题其实很隐蔽,尤其是uniapp H5 场景下刷新导致栈清理,很多开发者一开始都懵掉了。uniapp 内部对「页面栈只有一个」时的返回逻辑是reLaunch;所以只要在这个分支里替换为自己的逻辑(比如),就能顺利实现预期。目前我在项目里已经跑通了,暂时没发现问题。不得不说,知道源码里这个逻辑后,真的是醍醐灌顶,只能膜拜框架大佬了 🤯。

代码简单说 Vue、JAVA、PHP、Node.js 熟练运用,接口、架构、性能全搞定。 526

数学建模模型总结

这是本人在两年内准备参加数学建模竞赛搜集到的模型资料,已经经过了本人的筛选和整理,希望能够对准备参加数学建模竞赛的学弟学妹们提供一些帮助!

Linux内核同步方法

原子操作 自旋锁、读-写自旋锁 信号量:二值信号量、读-写信号量 互斥量 完成变量

瓦釜苑 673

老版QQ原生表情gif动态

这是老版的QQ表情,不过全是动态的的,Windows照片查看器是不会动的,可以右击用浏览器打开查看,再说一遍是老版的,只是分享给宁愿用老版也要动态的人。

【Kernel】内核同步

【Kernel】内核同步 内核源码快捷查看 一、什么是内核同步 同步是指用于实现控制多个进程按照一定的规则或顺序访问某些系统资源的机制。 内核同步这里有一个官方形式的说法,但个人认为这一解释对理解其实际功能没什么帮助,这里仅仅对其进行引用。为了便于理解,这里介绍两个概念,临界区和竞争条件。 临界区:访问和操作共享数据的代码段。 竞争条件:两个执行线程在同一临界区中同时执行。 使用内核同步解决共享资源并发访问的问题。如果多个执行线程同时访问和操作数据,就有可能发生各线程之间相互覆盖共享数据的情况,造成被访问数

qq_40392981的博客 1290

android 蓝牙通讯demo

android 下蓝牙通讯demo,实现了发现蓝牙,使能蓝牙,通过蓝牙发送消息。

Linux内核同步,进程,线程同步各种方法

Linux内核同步,进程,线程同步各种方法包括我自己在内,很多人对内核,进程,线程同步都不是很清楚,下面稍微总结一下:内核同步:主要是防止多核处理器同时访问修改某段代码,或者在对设备驱动程序进行临界区保护。主要有一下几种方式:1. Mutex(互斥)头文件:#include 初始化方法:DEFINE_MUTEX(name);或者void mutex_init(struct mutex *lock);使用方法:void mutex_lock (struct mutex *lock);Tries to lock

cainiao413的专栏 936

内核中的调度与同步

内核中的调度与同步摘要本章将为大家介绍内核中存在的各种任务调度机理以及它们之间的逻辑关系(这里将覆盖进程调度、推后执行、中断等概念),在此基础上向大家解释内核中需要同步保护的根本原因和保护方法。最后提供一个内核共享链表同步访问的例子,帮助大家理解内核编程中的同步问题。内核任务调度与同步关系引言对于从事应用程序开发的朋友来说,用户空间的任务调度与同步之间的关系相对简单,无需过多考虑需

康华的专栏 3278

Linux内核深入学习 - 内核同步

在我们开始之前,先来看看内核抢占,他是我们为了解决的东西而引出来的内核同步!

charlie114514191的博客 1442

linux 内核同步方法,学习笔记之Linux内核同步方法

一、程序并发执行的原因在用户空间:调度程序完全可能选择另一个高优先级的进程到处理器上执行,所以就有可能一个程序正处于临界区时被非自愿的抢占了,如果新调度的的进程随后也进入到同一个临界区,前后两个进程之间就会产生竞争。信号是异步发生的也有可能产生竞争条件。在内核空间:中断:中断几乎可以在任何时候异步发生,也就可能随时打断当前正在执行的代码。软中断和tasklet:内核能在任何时候唤醒或调度软中断和t...

weixin_34278722的博客 204

LKD 笔记:内核同步方法

文章目录原子操作原子的整数操作64 位原子操作原子的位操作自旋锁其他的自旋锁方法自旋锁和底半部读写自旋锁信号量计数和二值信号量创建和初始化信号量使用信号量读写信号量互斥锁完成变量顺序锁关掉内核抢占顺序与屏障 前一节介绍了内核同步,这一节介绍内核提供的同步方法。 原子操作 从 互斥锁与条件变量 这篇文章中我们知道:即使多个线程对同一个整数进行自增操作也会存在同步问题(因为整数的自增操作不是原子(性)的)。 因此内核提供了两类原子性的操作接口——一类接口操作一个整数,另一类接口操作整数中单独的某一位。这些接口的

alenliu's blog 709

Linux内核同步介绍和方法

Linux设备驱动中必须解决的一个问题是多个进程对共享资源的并发访问,并发访问会导致竞态,linux提供了多种解决竞态问题的方式,这些方式适合不同的应用场景。  Linux内核是多进程、多线程的操作系统,它提供了相当完整的内核同步方法。内核同步方法列表如下:中断屏蔽原子操作自旋锁读写自旋锁顺序锁信号量读写信号量BKL(大内核锁)Seq锁一、并发与竞态

wswifth的专栏 1018

linux内核同步的方法,[转载]linux内核同步方法-锁的使用

前面介绍了同步的概念以及使用的场合。接下来要介绍的是我们为了实现内核的同步,linux里面所提供的一些方法,当然从另外一个角度我们也可以看出linux的系统实现相当的完备。开头大致的罗列一下我们系统里面的同步方法吧:1.原子操作2.位操作3.自选锁4.读写锁5.信号量6.完成变量7.Seq锁8.禁止抢占9.BKL大内核锁10.。。。。。上面我们列举了那么多,不知道你常用那些来完成你的代码。反正我常...

weixin_32683881的博客 146
上一篇: 一些代码检查工具的信息
下一篇: spinlock与linux内核调度的关系,那么为什么信号量保护的代码可以睡眠而自旋锁就不能呢?
YasinLeeX
博客等级 码龄19年 380粉丝 310原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

YasinLeeX

再来一杯西湖龙井。

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值