devbox
Guff_9hys
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

活锁方案与自旋锁

作者：Guff_9hys | 2024-06-30 08:45:05

赞

踩

活锁方案与自旋锁

问题

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

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

解决方案：

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

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

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

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

互斥量获取超时 API 函数

"活锁" 解决方案实现

活锁解决方案

test-1.c

  1. #define _GNU_SOURCE     /* To get pthread_getattr_np() declaration */
  2. #include <pthread.h>
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <unistd.h>
  6. #include <memory.h>
  7. #include <time.h>
  8.  
  9. pthread_mutex_t m1 = PTHREAD_MUTEX_INITIALIZER;
  10. pthread_mutex_t m2 = PTHREAD_MUTEX_INITIALIZER;
  11.  
  12. int g_count = 0;
  13.  
  14. void live_lock(pthread_mutex_t* pm[], int n)
  15. {
  16.     int r = -1;
  17.     int i = 0;
  18.     int j = 0;
  19.     struct timespec tout = {0};
  20.         
  21.     while( r )
  22.     {    
  23.         for(i=0; i<n; i++)
  24.         {
  25.             clock_gettime(CLOCK_REALTIME, &tout);
  26.                 
  27.             tout.tv_sec += 1;
  28.                 
  29.             r = pthread_mutex_timedlock(pm[i], &tout);
  30.                  
  31.             if( r )
  32.             {
  33.                 for(j=0; j<i; j++)
  34.                 {
  35.                     pthread_mutex_unlock(pm[j]);
  36.                 }
  37.                 usleep(100 * 1000);
  38.                 break;
  39.             }
  40.         }
  41.     }
  42. }
  43.  
  44. void live_unlock(pthread_mutex_t* pm[], int n)
  45. {
  46.     int i = 0;
  47.     
  48.     while( i < n )
  49.     {
  50.         pthread_mutex_unlock(pm[i++]);
  51.     }
  52. }
  53.  
  54. void* thread_1(void* arg)
  55. {  
  56.     pthread_mutex_t* pm[] = {&m1, &m2};
  57.     int n = sizeof(pm)/sizeof(*pm);
  58.     
  59.     while(1)
  60.     {
  61.         live_lock(pm, n);
  62.  
  63.         printf("%s : %d\n", __FUNCTION__, g_count++);
  64.         
  65.         usleep(100);
  66.             
  67.         live_unlock(pm, n);
  68.     }
  69.     
  70.     pthread_detach(pthread_self());
  71.     
  72.     return NULL;
  73. }
  74.  
  75. void* thread_2(void* arg)
  76. {  
  77.     pthread_mutex_t* pm[] = {&m2, &m1};
  78.     int n = sizeof(pm)/sizeof(*pm);
  79.     
  80.     while(1)
  81.     {
  82.         live_lock(pm, n);
  83.  
  84.         printf("%s : %d\n", __FUNCTION__, g_count++);
  85.         
  86.         usleep(100);
  87.             
  88.         live_unlock(pm, n);
  89.     }
  90.     
  91.     pthread_detach(pthread_self());
  92.     
  93.     return NULL;
  94. }
  95.  
  96. int main()
  97. {
  98.     int r = 0;
  99.     pthread_t t;
  100.     
  101.     pthread_create(&t, NULL, thread_1, NULL);
  102.     pthread_create(&t, NULL, thread_2, NULL);
  103.     
  104.     printf("Hello World!\n");
  105.     
  106.     while( 1 )
  107.     {
  108.         sleep(1);
  109.     }
  110.     
  111.     return 0;
  112. }

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

  1. #define _GNU_SOURCE     /* To get pthread_getattr_np() declaration */
  2. #include <pthread.h>
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <unistd.h>
  6. #include <memory.h>
  7. #include <time.h>
  8.  
  9. int g_count = 0;
  10. pthread_mutex_t g_mutex;
  11. pthread_spinlock_t g_spin;
  12.  
  13. void* thread_1(void* arg)
  14. {  
  15.     while(1)
  16.     {
  17.         pthread_spin_lock(&g_spin);
  18.         // pthread_mutex_lock(&g_mutex);
  19.  
  20.         printf("%s : %d\n", __FUNCTION__, g_count++);
  21.        
  22.         usleep(100 * 1000);
  23.         
  24.         pthread_spin_unlock(&g_spin);
  25.         // pthread_mutex_unlock(&g_mutex);
  26.     }
  27.     
  28.     pthread_detach(pthread_self());
  29.     
  30.     return NULL;
  31. }
  32.  
  33. void* thread_2(void* arg)
  34. {  
  35.     while(1)
  36.     {
  37.         pthread_spin_lock(&g_spin);
  38.         // pthread_mutex_lock(&g_mutex);
  39.  
  40.         printf("%s : %d\n", __FUNCTION__, g_count++);
  41.        
  42.         usleep(100 * 1000);
  43.         
  44.         pthread_spin_unlock(&g_spin);
  45.         // pthread_mutex_unlock(&g_mutex);
  46.     }
  47.     
  48.     pthread_detach(pthread_self());
  49.     
  50.     return NULL;
  51. }
  52.  
  53. int main()
  54. {
  55.     int r = 0;
  56.     pthread_t t;  
  57.     
  58.     pthread_mutexattr_t mattr;
  59.     
  60.     pthread_mutexattr_init(&mattr);
  61.     pthread_mutex_init(&g_mutex, &mattr);
  62.     
  63.     pthread_spin_init(&g_spin, PTHREAD_PROCESS_PRIVATE);
  64.     
  65.     pthread_create(&t, NULL, thread_1, NULL);
  66.     pthread_create(&t, NULL, thread_2, NULL);
  67.     
  68.     printf("Hello World!\n");
  69.     
  70.     while( 1 )
  71.     {
  72.         // printf("%s : %d\n", __FUNCTION__, g_count);
  73.         sleep(1);
  74.     }
  75.     
  76.     return 0;
  77. }

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

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

我们使用 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

  1. #define _GNU_SOURCE     /* To get pthread_getattr_np() declaration */
  2. #include <pthread.h>
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <unistd.h>
  6. #include <memory.h>
  7. #include <time.h>
  8.  
  9. int g_count = 0;
  10. pthread_mutex_t g_mutex;
  11.  
  12. void* thread_1(void* arg)
  13. {  
  14.     while(1)
  15.     {
  16.         pthread_mutex_lock(&g_mutex);
  17.  
  18.         printf("%s : %d\n", __FUNCTION__, g_count++);
  19.        
  20.         usleep(100 * 1000);
  21.         
  22.         pthread_mutex_unlock(&g_mutex);
  23.     }
  24.     
  25.     pthread_detach(pthread_self());
  26.     
  27.     return NULL;
  28. }
  29.  
  30. void* thread_2(void* arg)
  31. {  
  32.     while(1)
  33.     {
  34.         pthread_mutex_lock(&g_mutex);
  35.  
  36.         printf("%s : %d\n", __FUNCTION__, g_count++);
  37.        
  38.         usleep(100 * 1000);
  39.         
  40.         pthread_mutex_unlock(&g_mutex);
  41.     }
  42.     
  43.     pthread_detach(pthread_self());
  44.     
  45.     return NULL;
  46. }
  47.  
  48. int main()
  49. {
  50.     int r = 0;
  51.     pthread_t t;  
  52.     
  53.     pthread_mutexattr_t mattr;
  54.     
  55.     pthread_mutexattr_init(&mattr);
  56. 	pthread_mutexattr_settype(&mattr, PTHREAD_MUTEX_ADAPTIVE_NP);
  57.     pthread_mutex_init(&g_mutex, &mattr);
  58.     
  59.     pthread_create(&t, NULL, thread_1, NULL);
  60.     pthread_create(&t, NULL, thread_2, NULL);
  61.     
  62.     printf("Hello World!\n");
  63.     
  64.     while( 1 )
  65.     {
  66.         // printf("%s : %d\n", __FUNCTION__, g_count);
  67.         sleep(1);
  68.     }
  69.     
  70.     return 0;
  71. }

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

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

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

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Guff_9hys/article/detail/772014
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号