活锁方案与自旋锁

已于 2024-03-31 19:25:40 修改
阅读量445 收藏 6
点赞数 5
分类专栏： Linux系统编程 文章标签： linux
于 2024-02-05 17:28:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52484093/article/details/136044756
版权

问题

如何设置获取互斥量时的等待时间？
如果等待超时，如何避免死锁？

避免死锁 -- 设置等待超时

解决方案：

1、尝试获取第 1 个互斥量：

  • 若成功，则转 2 执行；若失败，则等待；

2、尝试在规定时间内获取第 2 个互斥量：

  • 若成功，则执行临界区代码
  • 若失败，则释放第 1 个互斥量，休眠后转 1 执行

互斥量获取超时 API 函数

"活锁" 解决方案实现

活锁解决方案

test-1.c

#define _GNU_SOURCE     /* To get pthread_getattr_np() declaration */
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <memory.h>
#include <time.h>

pthread_mutex_t m1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t m2 = PTHREAD_MUTEX_INITIALIZER;

int g_count = 0;

void live_lock(pthread_mutex_t* pm[], int n)
{
    int r = -1;
    int i = 0;
    int j = 0;
    struct timespec tout = {0};
        
    while( r )
    {    
        for(i=0; i<n; i++)
        {
            clock_gettime(CLOCK_REALTIME, &tout);
                
            tout.tv_sec += 1;
                
            r = pthread_mutex_timedlock(pm[i], &tout);
                 
            if( r )
            {
                for(j=0; j<i; j++)
                {
                    pthread_mutex_unlock(pm[j]);
                }
                usleep(100 * 1000);
                break;
            }
        }
    }
}

void live_unlock(pthread_mutex_t* pm[], int n)
{
    int i = 0;
    
    while( i < n )
    {
        pthread_mutex_unlock(pm[i++]);
    }
}

void* thread_1(void* arg)
{  
    pthread_mutex_t* pm[] = {&m1, &m2};
    int n = sizeof(pm)/sizeof(*pm);
    
    while(1)
    {
        live_lock(pm, n);

        printf("%s : %d\n", __FUNCTION__, g_count++);
        
        usleep(100);
            
        live_unlock(pm, n);
    }
    
    pthread_detach(pthread_self());
    
    return NULL;
}

void* thread_2(void* arg)
{  
    pthread_mutex_t* pm[] = {&m2, &m1};
    int n = sizeof(pm)/sizeof(*pm);
    
    while(1)
    {
        live_lock(pm, n);

        printf("%s : %d\n", __FUNCTION__, g_count++);
        
        usleep(100);
            
        live_unlock(pm, n);
    }
    
    pthread_detach(pthread_self());
    
    return NULL;
}

int main()
{
    int r = 0;
    pthread_t t;
    
    pthread_create(&t, NULL, thread_1, NULL);
    pthread_create(&t, NULL, thread_2, NULL);
    
    printf("Hello World!\n");
    
    while( 1 )
    {
        sleep(1);
    }
    
    return 0;
}

live_lock() 函数是我们实现的活锁解决方案，这个函数支持任意把锁，我们这里设置的超时时间是 1s，如果 1s 内没有获取到锁，则释放已经获取到的锁

在 mian() 函数中，我们创建两个线程，thread_1 先获取互斥量 m1，再获取互斥量 m2，而 thread_2 先获取互斥量 m2，再获取互斥量 m1，他们获取互斥量存在一个环路，可能会导致死锁，而这里使用的活锁方案就可以避免死锁

程序运行结果如下图所示：

当 thread_1 获取到 互斥量 m1，thread_2 获取到互斥量 m2，其中一个互斥量会由于在超时时间内抢夺不到互斥锁而放弃之前获取到的锁，这样另一个线程就能获取到锁，访问临界区

思考

线程获取互斥量失败后究竟发生了什么？

线程会进入阻塞状态，让出 cpu 的执行权，等到互斥量被释放，线程才有机会得到执行

Linux 中的自旋锁

自旋锁也是一种用于保证临界区的原子性的机制

自旋锁与互斥量类似，在任何时刻，最多只能有一个持有者

自旋锁与互斥量在内部机制上不同：

  • 互斥量：
    • 如果已经被其他线程持有，则当前线程进入等待状态 (不占用处理器，进入等待队列)
  • 自旋锁：
    • 如果已经被其他线程持有，则当前线程一直循环查看自旋锁是否再次可持有

互斥量 vs 自旋锁

应用场景

  • 互斥量是一种普适的解决方案，通用性强，副作用小
  • 自旋锁是一种特定场景下的解决方案，通用性弱，副作用大

实现机制

  • 互斥量涉及线程上下文切换，因此在效率上存在不足 (消耗时间资源)
  • 线程一直尝试获取自旋锁，因此不会进入阻塞状态 (消耗处理器资源)

Linux 中的自旋锁 API 函数

自旋锁类型：

  • PTHREAD_PROCESS_PRIVATE => 进程内自旋锁 (同一进程中的线程可用)
  • PTHREAD_PROCESS_SHARED => 进程间自旋锁 (任意进程的任意线程可用)

下面的多线程程序有问题吗？

自旋锁实验

test-2.c

#define _GNU_SOURCE     /* To get pthread_getattr_np() declaration */
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <memory.h>
#include <time.h>

int g_count = 0;
pthread_mutex_t g_mutex;
pthread_spinlock_t g_spin;

void* thread_1(void* arg)
{  
    while(1)
    {
        pthread_spin_lock(&g_spin);
        // pthread_mutex_lock(&g_mutex);

        printf("%s : %d\n", __FUNCTION__, g_count++);
       
        usleep(100 * 1000);
        
        pthread_spin_unlock(&g_spin);
        // pthread_mutex_unlock(&g_mutex);
    }
    
    pthread_detach(pthread_self());
    
    return NULL;
}

void* thread_2(void* arg)
{  
    while(1)
    {
        pthread_spin_lock(&g_spin);
        // pthread_mutex_lock(&g_mutex);

        printf("%s : %d\n", __FUNCTION__, g_count++);
       
        usleep(100 * 1000);
        
        pthread_spin_unlock(&g_spin);
        // pthread_mutex_unlock(&g_mutex);
    }
    
    pthread_detach(pthread_self());
    
    return NULL;
}

int main()
{
    int r = 0;
    pthread_t t;  
    
    pthread_mutexattr_t mattr;
    
    pthread_mutexattr_init(&mattr);
    pthread_mutex_init(&g_mutex, &mattr);
    
    pthread_spin_init(&g_spin, PTHREAD_PROCESS_PRIVATE);
    
    pthread_create(&t, NULL, thread_1, NULL);
    pthread_create(&t, NULL, thread_2, NULL);
    
    printf("Hello World!\n");
    
    while( 1 )
    {
        // printf("%s : %d\n", __FUNCTION__, g_count);
        sleep(1);
    }
    
    return 0;
}

程序运行结果如下图所示：

程序正常正确的运行了，不会产生死锁

我们使用 echo $$ 命令，查看 shell 进程的 pid

shell 进程的 pid 为 2274

使用 sudo chrt -p -f 10 2274 命令，改变 shell 的调度策略为 FIFO，这样在 shell 上执行的进程的默认都是实时进程，进程调度策略为 FIFO

最后使用 taskset -c 0 ./a.out 命令，指定这个程序在 cpu0 上执行

程序运行结果如下图所示：

程序发生了死锁，a.out 程序 cpu 占用率快达到 100%

这是因为 thread_1 优先获取到执行权，获取到自旋锁，打印后，通过 usleep() 主动释放 cpu 资源，调度到 thread_2 时，thread_2 会一直获取不到自旋锁，原地自旋，一直消耗cpu 资源，由于进程的调度策略是 FIFO，只有 thread_2 主动释放 cpu 资源，cpu0 才能调度其他线程执行，由于 thread_2 一直无法获取到自旋锁，所以这个程序产生了死锁，并且 thread_2 一直在消耗 cpu 资源

我们使用互斥锁，将自旋锁的代码注释掉，互斥锁的代码打开，再重复进行一次上面的实验

程序没有发生死锁，并且 cpu 的占用率很低

这是因为 thread_2 获取不到互斥锁，会进入阻塞状态，让出 cpu 资源，从而 cpu0 可以调度 thread_1 执行

自旋锁使用细则

轻量级锁定，即：临界区相对短小，自旋锁持有时间非常短

同一线程不可重复获取自旋锁 (导致死锁)

如果只有一个单核处理器，不建议使用自旋锁

线程一旦获取自旋锁，则不能让出处理器使用权

即：线程 获取锁 到 释放锁 的时间内只有一个执行流

有没有一种可能

存在一种 "锁" 类型：

  • 效率高 => 不会轻易发生上下文切换，使得线程进入阻塞状态
  • 无死锁 => 不会无限制自旋，适合的时间让出处理器使用权

关于 PTHREAD_MUTEX_ADAPTIVE_NP 类型

一种特殊的互斥量，又名：自适应锁

自适应锁先以自旋的方式持续尝试获取目标锁

当超时未能获取目标锁，则让出处理器使用权，线程进入阻塞状态

自适应锁相对普通互斥量效率更高，相对自旋锁安全性更好

下面的多线程程序有问题吗？

自适应锁实验

test-3.c

#define _GNU_SOURCE     /* To get pthread_getattr_np() declaration */
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <memory.h>
#include <time.h>

int g_count = 0;
pthread_mutex_t g_mutex;

void* thread_1(void* arg)
{  
    while(1)
    {
        pthread_mutex_lock(&g_mutex);

        printf("%s : %d\n", __FUNCTION__, g_count++);
       
        usleep(100 * 1000);
        
        pthread_mutex_unlock(&g_mutex);
    }
    
    pthread_detach(pthread_self());
    
    return NULL;
}

void* thread_2(void* arg)
{  
    while(1)
    {
        pthread_mutex_lock(&g_mutex);

        printf("%s : %d\n", __FUNCTION__, g_count++);
       
        usleep(100 * 1000);
        
        pthread_mutex_unlock(&g_mutex);
    }
    
    pthread_detach(pthread_self());
    
    return NULL;
}

int main()
{
    int r = 0;
    pthread_t t;  
    
    pthread_mutexattr_t mattr;
    
    pthread_mutexattr_init(&mattr);
	pthread_mutexattr_settype(&mattr, PTHREAD_MUTEX_ADAPTIVE_NP);
    pthread_mutex_init(&g_mutex, &mattr);
    
    pthread_create(&t, NULL, thread_1, NULL);
    pthread_create(&t, NULL, thread_2, NULL);
    
    printf("Hello World!\n");
    
    while( 1 )
    {
        // printf("%s : %d\n", __FUNCTION__, g_count);
        sleep(1);
    }
    
    return 0;
}

第 56 行，将互斥锁的类型设置为自适应锁

程序运行结果如下图所示：

程序正常正确的运行了，不会发生死锁

qq_52484093
关注
  • 5
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
自旋锁
dsl
06-17 182
好处 如果不是自旋锁，一般为了保证高并发下的数据完整性，会在共享资源上加synchorinzed锁或者加lock锁，让线程一个个执行，这个执行完了执行下一个，直到锁释放，下一个线程执行，在上一个线程没有释放锁的情况下，下一个线程就出现了wait阻塞操作，一直在等着，但是如果使用自旋锁（不在共享资源上加锁和释放锁），那么在上一个线程获得资源的情况下，它还是不能运行，但是它会通过while循环一直在调用方法（或者说询问）是否释放锁了锁，直到它能用锁锁住的资源了，避免了阻塞 坏处 ...
死锁、活锁、饥饿、自旋锁
Go中国
07-05 420
死锁 指两个或多个进程因互相持有对方所需的资源而处于等待状态，从而导致程序停止运行的现象。简单来说，在一个系统中，如果进程之间形成了一个循环依赖关系，那么就会发生死锁。图片来源: https://www.scientecheasy.com/2020/08/deadlock-in-java.html/???? 本文所有代码实现语言为 Go, 其他语言的读者可以使用读伪代码的思路来阅读代码，主要目的在于理...
读者写者问题，单例模式，自旋锁
weixin_57023347的博客
09-27 439
一.读者写者问题 1.1 概念 读者和写者问题，描述的就是有些公共数据修改的机会比较少，读的机会反而很多。在编写多线程时，这种情况时非常常见的。比如：登录账户，每次登录的时候都在不断的读取后台数据库中保存的账户和密码信息，但是用户很少会修改。再比如：看新闻，一条新闻会有很多用户浏览，但是很少会有人修改。 通常情况下，再读的过程中，往往伴随着查找，中间耗时比较长。如果给这种代码加上互斥锁，会极大的降低我们程序的效率。但是又一种锁可以专门解决读多写少的情况，...
超级简单的程序锁.........
02-05
标题“超级简单的程序锁”暗示我们讨论的是一个轻量级的解决方案，它体积小巧，但功能实用。描述中的反复强调“只有几KB的简单程序锁”进一步表明这是一个设计简洁、效率高的程序锁实现。 程序锁的核心概念在于同步...
并发编程面试题汇总.docx并发编程是指在一个程序中同时执行多个独立的任务或操作的能力 在面试中，常常会问到与并发编程相关的问题
07-25
- **锁消除与锁粗化**： - **锁消除**：指在运行时，对于那些经过分析确定不可能存在数据竞争的锁进行消除，以减少不必要的同步开销。 - **锁粗化**：将多个短小的锁操作合并成一个较长的锁操作，减少锁的获取和...
java高并发系统设计
08-05
- **锁机制**：包括互斥锁、读写锁、自旋锁等，用于控制对共享资源的访问。 - **信号量Semaphore**：用于限制同时访问特定资源的线程数量。 - **条件变量Condition**：允许线程等待特定条件满足后再进行下一步...
java常见面试题汇总和解答
01-27
4. **锁机制**：Java提供了多种锁，如内置锁（互斥锁）、读写锁、乐观锁、自旋锁等，理解它们的工作原理和适用场景，对于优化多线程程序至关重要。 5. **数据存储**：面试中可能涉及JDBC操作数据库、NoSQL数据库...
Java并发编程全景图.pdf
02-09
锁是实现线程同步的关键机制，Java提供了不同类型的锁，包括乐观锁、悲观锁、自旋锁等。自旋锁利用了CPU空转等待，减少了线程上下文切换的开销。公平锁和非公平锁的区别在于线程获取锁的顺序。读写锁（如...
多进程和多线程基础概念LINUX
2301_79109608的博客
08-22 930
直接访问物理地址,会导致地址空间没有隔离,很容易导致数据被修改通过虚拟地址空间可以实现每个进程空间都是独立的，操作系统会映射到不用的物理地址区间，在访问时互不干扰.进程状态分为三个基本状态，即运行态，就绪态，阻塞态。在五态模型中，进程分为新建态、终止态，运行态，就绪态，阻塞态。并发：有限的 cpu 核芯的情况下 ,利用快速交替(时间片轮转)执行来达到宏观上的同时执行。虚拟地址 : 虚拟地址并不代表真实的内存空间,而是一个用于寻址的编号。并行：在 cpu 多核的支持下，实现物理上的同时执行。
Linux 线程的控制 互斥与同步
qq_63145217的博客
08-23 816
include //头文件sem_t sem;信号量的类型 信号量的变量。
虚拟内存和linux（操作系统part1）
最新发布
linjixia的博客
08-24 440
八股之虚拟内存和Linux部分的笔记。
Linux自旋锁和读写锁
m0_74830524的博客
08-24 352
在前面的文章中我们已经介绍了有关互斥锁的概念与使用，本篇将开始介绍在 Linux 中的自旋锁和读写锁。这三种锁分别用于在不同的应用场景之中，其中互斥锁最为常用，但是我们需要了解一下其他的锁。 对于自旋锁和读写锁都介绍了其原理以及接口使用，并且给出了样例代码。
在Linux上构建Windows应用程序：深入探索跨平台开发的实践与挑战
w651428055的博客
08-21 1075
在Linux上构建Windows应用程序，不仅拓宽了开发者的技能范围，也为软件产品的多平台部署提供了灵活性和成本效益。虽然这一过程面临挑战，但通过合理选择工具、框架和策略，可以有效地克服这些障碍。随着技术的不断进步，跨平台开发将变得更加成熟和便捷，为软件开发带来更多的可能性和机遇。未来，随着更多高效工具和框架的出现，跨平台开发的效率和质量有望进一步提升，为软件工程领域注入新的活力。
Linux中信号量相关接口及环形队列
2301_77479435的博客
08-22 309
Linux中信号量相关接口及环形队列
Linux 实用运维sh脚本分享
08-22 242
【代码】Linux 实用运维sh脚本分享。
linux查询目录文件基础操作
qq_43826626的博客
08-22 257
ls -l。
linux被植入木马排查思路
qq_59634082的博客
08-20 910
1、查看一定时间内文件的情况 find / -name "*" -type f -newermt '2022-08-25 00:00:00'!2、查看tomcat、nginx的比较大的.jsp .htm文件 find /目录 -name .jsp -o -size +10000k。在相应的文件里把tomcat2用户添加的内容删除 /etc/shadow /etc/group ，异常用户直接锁定。3、查看passwd的修改时间，判断是否在不知情的情况下被添加用户 ls -l /etc/passwd。
java死锁与活锁以及饥饿案例
03-03
Java中的死锁和活锁是多线程并发编程中的常见问题，这些问题可能会导致线程无法向前执行或陷入死循环。下面分别介绍Java中死锁和活锁的概念和案例。 1. 死锁 死锁是指两个或多个线程相互等待对方释放锁，从而导致所有线程都无法向前执行的状态。简单来说，当两个或多个线程都占有某些资源并且又想要获取对方占有的资源时，就会发生死锁。 下面是一个Java中的死锁例子： ```java public class DeadlockExample { private Object lock1 = new Object(); private Object lock2 = new Object(); public void method1() { synchronized (lock1) { System.out.println("Method 1: Holding lock 1..."); try { Thread.sleep(10); } catch (InterruptedException e) { e.printStackTrace(); } synchronized (lock2) { System.out.println("Method 1: Holding lock 1 and lock 2..."); } } } public void method2() { synchronized (lock2) { System.out.println("Method 2: Holding lock 2..."); try { Thread.sleep(10); } catch (InterruptedException e) { e.printStackTrace(); } synchronized (lock1) { System.out.println("Method 2: Holding lock 1 and lock 2..."); } } } public static void main(String[] args) { DeadlockExample example = new DeadlockExample(); Thread t1 = new Thread(() -> example.method1()); Thread t2 = new Thread(() -> example.method2()); t1.start(); t2.start(); } } ``` 在这个例子中，两个线程t1和t2分别调用了method1和method2方法，这两个方法都需要获取lock1和lock2两个锁才能继续执行。由于t1占用了lock1并等待lock2，而t2占用了lock2并等待lock1，因此两个线程都无法释放自己占用的锁，从而陷入死锁状态。 2. 活锁 活锁是指线程们都在运行并尝试执行任务，但是由于某些条件始终无法满足，导致线程们一直在重试，但是最终无法完成任务。这种情况下，线程们看起来像是在不断地活动，但是实际上却没有任何进展。 下面是一个Java中的活锁例子： ```java public class LiveLockExample { private boolean isPolite; public LiveLockExample(boolean isPolite) { this.isPolite = isPolite; } public void bow(LiveLockExample partner) { while (true) { if (isPolite) { System.out.println("I'm polite, I'll bow first"); partner.bowBack(this); isPolite = false; break;
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值