快速锁和递归锁,线上遇到锁问题分析

最新推荐文章于 2022-05-12 22:09:36 发布
最新推荐文章于 2022-05-12 22:09:36 发布
阅读量310 收藏
点赞数
分类专栏： 操作系统原理 文章标签： c语言
本文为博主原创文章，未经博主允许不得转载。
本文链接：https://blog.csdn.net/Poisx/article/details/114994141
版权

快速锁和递归锁,线上遇到锁问题分析

快速锁和递归锁,线上遇到锁问题分析

前言

最近线上出现CPU飚到 99%~101%, 这个情况就可以肯定判断是项目中代码进入到了死循环中了。 当时调试线上进程看到[__gthread_mutex_lock]这个函数上了。

一、锁介绍

1、锁的实现有两种实现方式

  1. 硬件实现
  2. 软件实现

① 硬件实现

② 软件实现

就是写一个标记位，当前标记位有人使用的时候就wait使要使用进入wait状态， 当前使用的状态是lock状态。

③ 实现使当前进程进入等待状态就是死锁

// 编译指令
// gcc -o die_lock die_lock.c -lpthread -g -Wall
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <assert.h>
#define UNUSED(OBJECT) (void)OBJECT
/// 死锁
void lock()
{
        int ret = 0;
        pthread_mutex_t mutex;
        ret = pthread_mutex_init(&mutex, NULL);
        assert(ret == 0);
        ret = pthread_mutex_lock(&mutex);
        assert(ret == 0);
        // 互斥锁 [__lll_lock_wait] 直到不用了 才会释放该锁  在使用得时候想加锁时就需要等待中了  [__lll_lock_wait]
        ret = pthread_mutex_lock(&mutex);
        assert(ret == 0);
		ret = pthread_mutex_destroy(&mutex);
        assert(ret == 0);
}

//正常使用不会死锁的
void lock_run()
{
int ret = 0;
        pthread_mutex_t mutex;
        ret = pthread_mutex_init(&mutex, NULL);
        assert(ret == 0);
        ret = pthread_mutex_lock(&mutex);
        assert(ret == 0);
        ret = pthread_mutex_unlock(&mutex);
        assert(ret == 0);
        ret = pthread_mutex_lock(&mutex);
        assert(ret == 0);
        ret = pthread_mutex_unlock(&mutex);
        assert(ret == 0);
        ret = pthread_mutex_destroy(&mutex);
        assert(ret == 0);
}


int main(int argc, char *argv[])
{
	lock();
	return 0;
}

在这里插入图片描述

④ 锁具体的使用

 /***********************************************************************************************
					created: 2020-05-20 
					author: chensong
					purpose: mutex 死锁问题 锁大致分为三种
								1. fast 快速  又名悲观锁 -- 互斥锁
								2. recursive 递归 又名乐观锁
								3. error check 错误检查
************************************************************************************************/
#include <stdio.h> 
#include <pthread.h> 
#include <unistd.h> 
#include <assert.h>

#define UNUSED(OBJECT) (void)OBJECT
// mutex -> 1. 'fast' 快速锁 default [PTHREAD_MUTEX_FAST_NP]
// 2. 'recursive' 递归锁 [PTHREAD_MUTEX_RECURSIVE_NP]
// 3. error check [PTHREAD_MUTEX_ERRORCHECK_NP] pthread_mutex_t mutex;
// 1 . 悲观锁
pthread_mutex_t mutex; 
void fast_mutex() 
{
	printf("[%s][%d]\n", __FUNCTION__, __LINE__); 
	pthread_mutexattr_t attr;
	int ret = 0;
	ret = pthread_mutexattr_init(&attr);
	assert(ret == 0);
	UNUSED(ret);
	int kind = 0;//mutex_attr
	ret = pthread_mutexattr_gettype(&attr, &kind); 
	assert(ret == 0);
	printf("[mutexattr_gettype kind = %d]\n", kind); 
	ret = pthread_mutex_init(&mutex, &attr);
	assert(ret == 0);
	ret = pthread_mutexattr_destroy(&attr); 
	assert(ret == 0);
	printf("[mutex init ok]\n"); //usleep(1000*1000);
	printf("timeout we will start dead lock\n");
	ret = pthread_mutex_lock(&mutex);
	assert(ret == 0);
	printf("[1mutex lock ok]\n");
	ret = pthread_mutex_lock(&mutex);
	assert(ret == 0);
	printf("[2mutex lock ok]\n");
}
// 2. 乐观锁
void recursive_mutex()
{ //
	pthread_mutexattr_t attr;
	int ret = 0;
	ret = pthread_mutexattr_init(&attr); 
	assert(ret == 0);
	UNUSED(ret);
	int kind = 0;//mutex_attr
	ret = pthread_mutexattr_gettype(&attr, &kind); 
	assert(ret == 0);
	printf("[mutexattr_gettype kind = %d]\n", kind);
	kind = PTHREAD_MUTEX_RECURSIVE_NP;
	ret = pthread_mutexattr_settype(&attr, kind); 
	assert(ret == 0);
	printf("[mutexattr_settype ok]");
	ret = pthread_mutexattr_gettype(&attr, &kind); 
	assert(ret == 0);
	printf("[mutexattr_gettype new kind = %d]\n", kind); 
	ret = pthread_mutex_init(&mutex, &attr);
	assert(ret == 0);
	ret = pthread_mutexattr_destroy(&attr);
	printf("[mutex init ok]\n");
	printf("timeout we will start dead lock\n"); 
	ret = pthread_mutex_lock(&mutex); 
	assert(ret == 0);
	printf("[1mutex lock ok]\n");
	ret = pthread_mutex_lock(&mutex); 
	assert(ret == 0);
	printf("[2mutex lock ok]\n");
	while (1)
	{
		usleep(1000*1000); 
	}
}
void error_mutex()
{
	// pthread_mutex_t mutex;
	pthread_mutexattr_t attr;
	int ret = 0;
	ret = pthread_mutexattr_init(&attr);
	assert(ret == 0);
	//assert(ret != 0);
	UNUSED(ret);
	int kind = 0;//mutex_attr
	ret = pthread_mutexattr_gettype(&attr, &kind); 
	assert(ret == 0);
	printf("[mutexattr_gettype kind = %d]\n", kind);
	kind = PTHREAD_MUTEX_ERRORCHECK_NP; 
	ret = pthread_mutexattr_settype(&attr, kind); 
	assert(ret == 0);
	printf("[mutexattr_settype ok]");
	ret = pthread_mutexattr_gettype(&attr, &kind); 
	assert(ret == 0);
	printf("[mutexattr_gettype new kind = %d]\n", kind); 
	ret = pthread_mutex_init(&mutex, &attr);
	assert(ret == 0);
	//assert(ret != 0);
	ret = pthread_mutexattr_destroy(&attr);
	assert(ret == 0);
	//assert(ret != 0);

	 printf("[mutex init ok]\n");
	printf("timeout we will start dead lock\n"); 
	ret = pthread_mutex_lock(&mutex); 
	assert(ret == 0);
//	assert(ret != 0);
	printf("[1mutex lock ok]\n"); //usleep(1000*1000);
	ret = pthread_mutex_lock(&mutex); 
	assert(ret == 0);
	printf("[2mutex lock ok]\n");
}
void *work_thread(void *arg) 
{
//		 fast_mutex();
		recursive_mutex(); 
		//error_mutex(); 
		return NULL;

}
void *alive_thread(void *arg) 
{
	int ret = 0;
	usleep(1000*1000);
	printf("[%s][%d]\n", __FUNCTION__, __LINE__); 
	ret = pthread_mutex_lock(&mutex);
	assert(ret == 0);
	//assert(ret != 0);
	UNUSED(ret);
	printf("[use mutex ok !!!]\n");
	while (1)
	{
		usleep(1000*1000); 
	}
}
int main(int argc, char *argv[]) 
{
	pthread_t dead_pid; 
	pthread_create(&dead_pid, 0, work_thread, 0); 
	pthread_t alive_pid;
	pthread_create(&alive_pid, 0, alive_thread, 0); 
	void *ret = NULL; //assert(pthread_join(dead_pid, &ret) != 0); 
	pthread_join(dead_pid, &ret) ;
	void *ret2 = NULL; //assert(pthread_join(alive_pid, &ret2) != 0); 
	pthread_join(alive_pid, &ret2);
	UNUSED(ret);
	UNUSED(ret2);
	return 0; 
}



project(cmutex)
CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
MESSAGE(STATUS "#########################")

ADD_DEFINITIONS( -g -Wall )

file(GLOB ALL_C_SRCS
./*.c
)

add_executable(${PROJECT_NAME} ${ALL_C_SRCS} )


set(ALL_LIB  pthread
	)


target_link_libraries(${PROJECT_NAME} ${ALL_LIB})
  • fast

在这里插入图片描述

  • recursive_mutex

在这里插入图片描述

二、线上的问题分析

问题效果图
在这里插入图片描述

上面是实际项目的问题

中途我把互斥锁给排除了, 这个问题只有递归锁才会触发（根据堆栈信息给排除了[ __gthread_active_p, __gthread_mutex_unlock]两个函数， 线程的状态不是等待状态（wait））。

1、中途我查看gun5.3的源码看一下递归锁怎么实现的

recursive_mutex的源码实现


// 设置递归锁
#if !defined( PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP) \
 || defined(_GTHREAD_USE_RECURSIVE_MUTEX_INIT_FUNC)
static inline int
__gthread_recursive_mutex_init_function (__gthread_recursive_mutex_t *__mutex)
{
 if (__gthread_active_p ())
   {
     pthread_mutexattr_t __attr;
     int __r;

     __r = __gthrw_(pthread_mutexattr_init) (&__attr);
     if (!__r)
   __r = __gthrw_(pthread_mutexattr_settype) (&__attr,
   					   PTHREAD_MUTEX_RECURSIVE); 
     if (!__r)
   __r = __gthrw_(pthread_mutex_init) (__mutex, &__attr);
     if (!__r)
   __r = __gthrw_(pthread_mutexattr_destroy) (&__attr);
     return __r;
   }
 return 0;
}
#endif

static inline int
__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex)
{
 return __gthread_mutex_lock (__mutex);
}

static inline int
__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex)
{
 return __gthread_mutex_trylock (__mutex);
}

#if _GTHREAD_USE_MUTEX_TIMEDLOCK
static inline int
__gthread_recursive_mutex_timedlock (__gthread_recursive_mutex_t *__mutex,
   			     const __gthread_time_t *__abs_timeout)
{
 return __gthread_mutex_timedlock (__mutex, __abs_timeout);
}
#endif

static inline int
__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex)
{
 return __gthread_mutex_unlock (__mutex);
}

static inline int
__gthread_recursive_mutex_destroy (__gthread_recursive_mutex_t *__mutex)
{
 return __gthread_mutex_destroy (__mutex);
}


  // Common base class for std::recursive_mutex and std::recursive_timed_mutex
 class __recursive_mutex_base
 {
 protected:
   typedef __gthread_recursive_mutex_t		__native_type;

   __recursive_mutex_base(const __recursive_mutex_base&) = delete;
   __recursive_mutex_base& operator=(const __recursive_mutex_base&) = delete;

#ifdef __GTHREAD_RECURSIVE_MUTEX_INIT
   __native_type  _M_mutex = __GTHREAD_RECURSIVE_MUTEX_INIT;

   __recursive_mutex_base() = default;
#else
   __native_type  _M_mutex;

   __recursive_mutex_base()
   {
     // XXX EAGAIN, ENOMEM, EPERM, EBUSY(may), EINVAL(may)
     __GTHREAD_RECURSIVE_MUTEX_INIT_FUNCTION(&_M_mutex);//__gthread_recursive_mutex_init_function
   }

   ~__recursive_mutex_base()
   { __gthread_recursive_mutex_destroy(&_M_mutex); }
#endif
 };


 /// recursive_mutex
 class recursive_mutex : private __recursive_mutex_base
 {
 public:
   typedef __native_type* 			native_handle_type;

   recursive_mutex() = default;
   ~recursive_mutex() = default;

   recursive_mutex(const recursive_mutex&) = delete;
   recursive_mutex& operator=(const recursive_mutex&) = delete;

   void
   lock()
   {
     int __e = __gthread_recursive_mutex_lock(&_M_mutex);

     // EINVAL, EAGAIN, EBUSY, EINVAL, EDEADLK(may)
     if (__e)
   __throw_system_error(__e);
   }

   bool
   try_lock() noexcept
   {
     // XXX EINVAL, EAGAIN, EBUSY
     return !__gthread_recursive_mutex_trylock(&_M_mutex);
   }

   void
   unlock()
   {
     // XXX EINVAL, EAGAIN, EBUSY
     __gthread_recursive_mutex_unlock(&_M_mutex);
   }

   native_handle_type
   native_handle()
   { return &_M_mutex; }
 };

2、问题重现

下面我使用最简单的c语言来实现上面一样的问题 CPU 99%~101%

// 编译指令
// gcc -o die_lock die_lock.c -lpthread -g -Wall
 #include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <assert.h>


#define UNUSED(OBJECT) (void)OBJECT


pthread_mutex_t recursive_mutex;

void recursive_mutex_three_lock(pthread_mutex_t * recursive_mutex)
{
        // 解   
        pthread_mutex_t mutex = *recursive_mutex;

        pthread_mutexattr_t attr;
        int ret = 0;
        ret = pthread_mutexattr_init(&attr);
        assert(ret == 0);
        UNUSED(ret);
        int kind = 0;//mutex_attr
        ret = pthread_mutexattr_gettype(&attr, &kind);
        assert(ret == 0);
        kind = PTHREAD_MUTEX_RECURSIVE_NP;
        ret = pthread_mutexattr_settype(&attr, kind);
        assert(ret == 0);
        ret = pthread_mutexattr_gettype(&attr, &kind);
        assert(ret == 0);
        ret = pthread_mutex_init(&mutex, &attr);
        assert(ret == 0);
        ret = pthread_mutexattr_destroy(&attr);
        assert(ret == 0);
        ret = pthread_mutex_lock(&mutex);
        assert(ret == 0);
        ret = pthread_mutex_unlock(&mutex);
        assert(ret == 0);
        

}
int get_three_lock()
{
        recursive_mutex_three_lock(&recursive_mutex);
        return 1;

}
void show()
{
        while (1)
        {
        //不停调用该函数 使用会在底层锁上停留的时间比较长 --->[__GI___pthread_mutex_lock]
                int w = get_three_lock();
                UNUSED(w);
        }
}
int main()
{

       	show();

        return 0;
}

在这里插入图片描述

看堆栈信息是__GI__thread_mutex_init函数上的但是一直调用recursive_mutex_three_lock函数的在__GI__thread_mutex_init上停留的时间比较长

CPU使用情况
在这里插入图片描述

三、GDB的命令

  1. 查看线程：info threads
  2. 进入线程：thread num
  3. gdb 调试进入函数体: ‘s’
  4. 查看堆栈信息: bt

总结

chen_song_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
递归锁，死锁，使用递归锁解决死锁，信号量
weixin_30271335的博客
09-18 679
递归锁 互斥锁 from threading import Lock lock_1 = Lock() lock_1.acquire() lock_1.acquire() print(123) # 打印结果:无法打印，并且程序阻塞住了 递归锁 from threading import RLock lock_2 = RLock() lock_2.acquire() lock_2.a...
递归锁小总结
weixin_30537391的博客
09-10 153
首先，递归锁是什么 首先，对于互斥锁，分为递归锁和非递归锁。 在不同的线程中调用已锁定的互斥锁，必然会导致死锁。 但是在同一个线程中，如果想要多次获得一个锁，只能使用递归锁 其次，递归锁是不被提倡的，用到递归锁说明这个代码设计是有问题的。 更好的做法是，提取出一个被两个个公有函数调用的私有函数，这个私有函数无需锁定mutex 尽量使用非递归锁，在程...
pthread包的mutex实现分析
tlxamulet的博客
01-12 6515
pthread包 pthread是POSIX thread，一个在类UNIX系统下广泛使用的并发包，linux系统下在glibc库里实现。 pthread包里常用的mutex相关接口有： pthread_mutex_init pthread_mutex_lock pthread_mutex_trylock pthread_mutex_unlock pthread_mutex_dest...
spin用户态加锁源码分析
weixin_30794851的博客
09-27 201
源码分析版本：glic-2.9 spin_lock加锁 pthread_spin_lock： int pthread_spin_lock (lock) pthread_spinlock_t *lock; { asm ("\n" "1:\t" LOCK_PREFIX "decl %0\n\t" //锁总线，开始加锁，在%0 "...
c++多线程编程和死锁问题
Tzecto
05-12 1653
文章目录线程内容一. 怎么创建启动一个线程二. 子线程如何结束三. 主线程如何处理子线程线程间的互斥模拟车站三个窗口卖票解决--锁问题mtx.unlock 如果临界区里面return返回了，就访问不到了,所以用职智能锁线程间的同步通信机制简单介绍生产者消费者模型基于CAS操作的atomic原子类型 C++语言层面 thread windows -> createThread linux strace ./a.out -> pthread_create 线程内容 一. 怎么创建启动一个线程 主线
Python多线程操作之互斥锁、递归锁、信号量、事件实例详解
09-17
主要介绍了Python多线程操作之互斥锁、递归锁、信号量、事件,结合实例形式详细分析了Python多线程操作互斥锁、递归锁、信号量、事件相关概念、原理、用法与操作注意事项,需要的朋友可以参考下
java乐观锁原理与实现案例分析
08-25
java乐观锁原理与实现案例分析 java乐观锁是一种乐观的并发控制机制，它认为线程冲突的可能性小，比较乐观，直接去操作数据，如果发现数据已经被更改（通过版本号控制），则不更新数据，再次去重复所需操作，知道...
线程，线程锁，递归锁及队列，消费者模式（转自Alex li）
05-19
线程，线程锁，递归锁及队列，消费者模式（转自Alex li）
锁链 非递归做法C++.zip
06-22
显然，可以运用递归的方法解决此问题。但是你能否找到一个非递归算法呢？ 【输入输出】 输入：环的总数n。 输出：为尽量体现程序输出结果的层次，要求按照从n、n-1、n-2、……、1的顺序，将移除掉n号环的全部过程...
mips交叉编译 error: 'PTHREAD_MUTEX_ERRORCHECK_NP' was not declared in this scope
weixin_34355559的博客
11-28 510
在mips交叉编译时，设置互斥锁时，报以下错误，始终编译不过去。error: 'PTHREAD_MUTEX_ERRORCHECK_NP' was not declared in this scope各种百度，相关信息一条也没有找到，实在没办法了，各种尝试。打开linux平台和mips平台的pthread.h一对比才恍然大悟，原来在mips平台上，互斥锁类型使用...
c++ 递归锁
hyl999的专栏
03-30 5377
递归锁RECURSIVE_MUTEX的原理以及使用 标签：Multi_ThreadRecursive_Mutex 递归锁的作用 MutexLock mutex; void foo() { mutex.lock(); // do something mutex.unlock(); } void bar() { mutex.lock(); // do something foo(); mut...
从gcc局部static变量初始化看C/C++区别
weixin_30875157的博客
11-19 220
http://tsecer.blog.163.com/blog/static/15018172012259354952/ ==================================================== 一、局部/全局变量 局部变量在C++中的使用要频繁的多，并且功能也强大的多，但是这些强大功能的背后无疑会引入问题的复杂性，不想让马儿吃草只想让马儿跑的...
【Boost】boost库中thread多线程详解4——谈谈recursive_mutex(递归式互斥量)
晴天的专栏
09-01 1438
如果一个线程中可能在执行中需要再次获得锁的情况（例子：test_thread_deadlock），按常规的做法会出现死锁。 此时就需要使用递归式互斥量boost::recursive_mutex，例子（test_thread_recursivelock）来避免这个问题。boost::recursive_mutex不会产生上述的死锁问题，只是是增加锁的计数，但必须确保你unlock和lock的次数
递归锁 std::recursive_mutex和std::lock_guard结合使用
u011337602的博客
08-28 1万+
最近做redis连接池的时候，需要加锁保证redisContext在同一时刻只能被一个线程使用 但是在加锁的时候头疼了，有一些针对redisContext的操作是相互调用的，而这些操作也都是需要可以独立进行的。 简单来说，问题就是：加锁的操作需要相互嵌套，如果使用std::mutex 肯定会导致死锁，而重构代码，提取出共用部分的工作量又很大。 这个时候我发现了好东西std::recursi...
递归的优缺点
热门推荐
wangzhenling的专栏
03-02 4万+
优点： 1. 简洁 2.在树的前序，中序，后序遍历算法中，递归的实现明显要比循环简单得多。 缺点： 1.递归由于是函数调用自身，而函数调用是有时间和空间的消耗的：每一次函数调用，都需要在内存栈中分配空间以保存参数、返回地址以及临时变量，而往栈中压入数据和弹出数据都需要时间。->效率 2.递归中很多计算都是重复的，由于其本质是把一个问题分解成两个或者多个小问题，多个小问题存在相互重叠的部分
线程递归互斥：ACE_Recursive_Thread_Mutex类
发芽的石头
01-31 6304
线程递归互斥：ACE_Recursive_Thread_Mutex类      ACE_Recursive_Thread_Mutex实现了wrappe模式，该类的功能在于允许同一个线程内可递归的获取和释放mutex。 成员函数1. ACE_Recursive_Thread_Mutex调用函数ACE_OS::recursive_mutex_init初始化互斥量说明：函数ACE_O
Linux 互斥锁 递归锁 自旋锁 读写锁
Sakuya__的博客
09-06 3443
锁是什么，我们为什么要用到锁？回到问题的本质，我们在什么场景下会用到锁，是在针对于公共资源，也就是临界资源的使用。对于多线程编程，当两个或多个线程同时访问或对一个临界资源操作的时候，为了防止出现数据不一致的问题，我们在使用之前要进行加锁，使用完后进行解锁。 ...
C++中的互斥锁，递归锁，读写锁
最新发布
05-26
常见的锁有互斥锁，递归锁和读写锁。 1. 互斥锁（Mutex） 互斥锁是最常见的锁类型。它确保同一时间只有一个线程可以访问共享资源。当一个线程获取了互斥锁时，其他线程必须等待该线程释放锁之后才能获取锁。 2. ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值