pthread_mutex_lock引起的core

最新推荐文章于 2022-12-19 09:57:33 发布

最新推荐文章于 2022-12-19 09:57:33 发布 · 710 阅读

本文介绍了一个关于pthread线程锁使用的错误案例。当一个线程尝试锁定一个互斥锁时，另一个线程可能已经销毁了该锁，导致程序出现core dump。此问题展示了在多线程环境下正确管理互斥锁的重要性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

遇到一个奇怪的core

core在pthread_mutex_lock下一行

最后发现：

某个线程pthread_mutex_lock的时候，另一个线程已经pthread_mutex_destroy掉这个锁

确定要放弃本次机会？

福利倒计时

: :

立减 ¥

普通VIP年卡可用

立即使用

iteye_20478

关注关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
分享

复制链接

分享到 QQ

分享到新浪微博

扫一扫
举报

举报

【linux系统编程学习笔记】第十一节：线程的安全机制1(互斥锁)（pthread_mutex_lock、pthread_mutex_unlock、pthread_mutex_init ）

qq_44796935的博客

07-27

1128

互斥锁安全机制互斥锁互斥锁API pthread_mutex_init 初始化互斥锁 pthread_mutex_lock 上锁 pthread_mutex_trylock 尝试上锁 pthread_mutex_unlock 解锁 pthread_mutex_destroy 销毁互斥锁例程：安全机制由于线程它是共享进程里面所有的资源，自然包括虚拟内存里面的所有东西包（包含全局变量，堆内存，映射的内存及程序段落等），同时也继承了进程的所有资源...

pthread_mutex_lock线程锁使用简单示例

oywoywoyw的专栏

12-16

5746

#define __USE_LARGEFILE64 #define _LARGEFILE64_SOURCE #ifndef _GNU_SOURCE #define _GNU_SOURCE #endif #include #include #include #include #include #include #include #include #inclu

参与评论您还未登录，请先登录后发表或查看评论

pthread_mutex 引起的 core dump + 学习 gdb

wangkai6666的博客

06-27

4492

示例 #include <stdio.h> #include <unistd.h> #include "pthread.h" pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER; void * process(void * arg) { fprintf(stderr, "Starting process %s\n", (char *) arg); wh

pthread_mutex_t死锁

明潮的BLOG

11-03

6615

互斥量，也叫互斥锁。通常造成死锁的有两种方式： 1.线程A试图对用一个互斥量mutexA加锁两次，那么它自身就会陷入死锁状态，用伪代码表示就是： pthreadA: [cpp] view plain copy print? pthread_mutex_lock(&mutexA) pthread_mutex_lock(&mute

c# Thread 线程（三） lock线程锁

清风ai明月的专栏

06-02

9087

在多线程编程中，可能会有多个线程并发的（或同时）执行一段代码，但是某些情况下需要在同一时刻只能有一个线程执行，避免某些对象的调用冲突或内存使用冲突，这就需要用到锁（lock）。lock 关键字可以用来确保代码块完成运行，而不会被其他线程中断。在同一个时刻内只允许一个线程进入执行，而其他线程必须等待。 public partial class TestWindow : Window {...

Linux多线程编程: 死锁场景、原因分析、解决方案

JiMoKuangXiangQu的专栏

04-05

971

1. 前言限于作者能力水平，本文可能存在的谬误，因此而给读者带来的损失，作者不做任何承诺。 2. 本文目标列举各种pthread编程的死锁场景，并简要分析原因，之后给出（不一定最优的）解决方案。 3. 死锁场景 3.1 案例1 3.1.1 场景多个线程共享锁，然后再某个线程发***pthread_kill()/pthread_cancel()***调用，造成的死锁。代码如下： #include <pthread.h> #include <stdio.h> #include &l

(gdb) bt #0 __GI_raise (sig=sig@entry=6) at ../sysdeps/unix/sysv/linux/raise.c:50 #1 0x0000007f9edaca60 in __GI_abort () at abort.c:79 #2 0x0000007f9edb9438 in __assert_fail_base ( fmt=0x7f9eeb5960 "%s%s%s:%u: %s%sAssertion `%s' failed.\n%n", assertion=assertion@entry=0x7f9f258028 "mutex->__data.__owner == 0", file=file@entry=0x7f9f2581a8 "pthread_mutex_lock.c", line=line@entry=81, function=function@entry=0x7f9f2580a8 <__PRETTY_FUNCTION__.0> "__pthread_mutex_lock") at assert.c:92 #3 0x0000007f9edb949c in __GI___assert_fail ( assertion=assertion@entry=0x7f9f258028 "mutex->__data.__owner == 0", file=file@entry=0x7f9f2581a8 "pthread_mutex_lock.c", line=line@entry=81, function=function@entry=0x7f9f2580a8 <__PRETTY_FUNCTION__.0> "__pthread_mutex_lock") at assert.c:101 #4 0x0000007f9f24be60 in __GI___pthread_mutex_lock (mutex=0x555f9b13b8 <mutxflag>) at pthread_mutex_lock.c:81 #5 0x000000555f996a58 in main ()

04-03

嗯，用户的问题是关于调试程序崩溃，特别是定位pthread_mutex_lock断言失败的问题。首先，我需要回忆一下如何处理这类多线程问题。用户提到使用gdb的backtrace，所以应该从如何获取有效的堆栈跟踪开始。首先，当...

jna__pthread_mutex_lock: Assertion `mutex->__data.__owner == 0' failed.

07-12

我们正在处理一个关于JNA调用pthread_mutex_lock时出现断言失败的问题。错误信息为：Assertion 'mutex->__data.__owner == 0' failed。这通常表示在尝试锁定互斥锁时，互斥锁已经被当前线程或其他线程锁定，而断言...

``` typedef struct { pthread_mutex_t hLock; volatile int iIsRun; void* (* volatile pfnTask)(void*); //函数指针 void *arg; //任务参数 }Task; typedef struct { pthread_mutex_t StackLock; int iIDStack[MAX_TASK_NUM]; int iTopPointer; }Stack; static Stack g_IDTaskStack; static Task stTaskQueueAry[MAX_TASK_NUM]; //static int iTaskCount = 0; //static pthread_mutex_t stMutexQueue; //static pthread_cond_t stCondQueue; static pthread_t stThreadAry[cmnDfn_WORKING_PTHREAD_NUMBER]; void* PthreadPoolWorker(void* arg) { int iRet = -1; int iTskID = (int)(long)arg; Task *pstTsk = &stTaskQueueAry[iTskID]; while(g_iExit == 0) { LOCK(pstTsk->hLock) { if (pstTsk->iIsRun == 0) { sleep(1); continue; } } iRet = (int)(long)pstTsk->pfnTask(pstTsk->arg); if (iRet == 0) { continue; } LOCK(pstTsk->hLock) { pstTsk->pfnTask = NULL; pstTsk->iIsRun = 0; } LOCK(g_IDTaskStack.StackLock) { g_IDTaskStack.iIDStack[++g_IDTaskStack.iTopPointer] = iTskID; } if(iRet < 0) { break; } } iRet = 0; return (void *)(long)iRet; } int ThreadPoolSubmit(void* (*task)(void*),void* arg,int *piTskID) { //int iLoopNum; int iTskID = 0; /*for(iLoopNum = 0; iLoopNum < MAX_TASK_NUM;iLoopNum++) { if (stTaskQueueAry[iLoopNum].pfnTask == NULL) { break; } } if(iLoopNum >= MAX_TASK_NUM) { return -1; }*/ if(g_IDTaskStack.iTopPointer < 0) { return -1; } LOCK(g_IDTaskStack.StackLock) { iTskID = g_IDTaskStack.iIDStack[g_IDTaskStack.iTopPointer--]; assert(iTskID >= 0 && iTskID < MAX_TASK_NUM); } LOCK(stTaskQueueAry[iTskID].hLock) { stTaskQueueAry[iTskID].pfnTask = task; stTaskQueueAry[iTskID].arg = arg; stTaskQueueAry[iTskID].iIsRun = 1; *piTskID = iTskID; } return 0; } int ThreadPoolInit(void) { int iLoopNum; int iRet = -1; int iTskID = 0; g_IDTaskStack.iTopPointer = -1; if(pthread_mutex_init(&g_IDTaskStack.StackLock,NULL) < 0) { cmn_PrtError("Error in initializing stack mutex"); } for(iLoopNum = 0; iLoopNum < cmnDfn_WORKING_PTHREAD_NUMBER; iLoopNum++) { g_IDTaskStack.iIDStack[++g_IDTaskStack.iTopPointer] = iLoopNum; } for(iLoopNum = 0; iLoopNum < cmnDfn_WORKING_PTHREAD_NUMBER; iLoopNum++) { if(pthread_mutex_init(&stTaskQueueAry[iLoopNum].hLock,NULL) < 0) { cmn_PrtError("Error in initializing mutex"); } if(pthread_create(&stThreadAry[iLoopNum],NULL,PthreadPoolWorker,(void *)(long)iTskID) != 0) { cmn_PrtError("Error in creating thread"); } stTaskQueueAry[iLoopNum].pfnTask = NULL; stTaskQueueAry[iLoopNum].iIsRun = 0; iTskID++; } iRet = 0; _Exit: return iRet; } int ThreadPoolDestroy(void) { int iLoopNum; int iRet = -1; g_iExit = 1; for(iLoopNum = 0; iLoopNum < cmnDfn_WORKING_PTHREAD_NUMBER; iLoopNum++) { pthread_join(stThreadAry[iLoopNum], NULL); } for(iLoopNum = 0; iLoopNum < cmnDfn_WORKING_PTHREAD_NUMBER; iLoopNum++) { pthread_mutex_destroy(&stTaskQueueAry[iLoopNum].hLock); } iRet = 0; return iRet; } #define MAX_TASK_NUM 256 #define cmnDfn_WORKING_PTHREAD_NUMBER 10```段错误 (核心已转储)

03-19

假设LOCK是一个宏，正确展开为pthread_mutex_lock和pthread_mutex_unlock，比如： #define LOCK(mtx) pthread_mutex_lock(&(mtx)); \ // ... some code ... \ pthread_mutex_unlock(&(mtx)); 但通常，加锁和解锁...

#00 pc 00000000000859c0 /apex/com.android.runtime/lib64/bionic/libc.so (pthread_mutex_lock) (BuildId: 81010bc67a9a7e1be57ac70818f446ca) #01 pc 00000000000a248c /system/lib64/libc++.so (std::__1::mutex::lock()+12) (BuildId: ada37e5198285720b02f7d77fd27626c7782fe29) #02 pc 00000000003ae5f0 /system_ext/lib64/libsurfaceflinger.so (android::TransactionTracing::writeToProto()+48) (BuildId: ac2cbaf325d9d0fe03c4095f438a21ef)

最新发布

08-09

- **`mutex lock`**：在 Android 源码中，常指 `Mutex` 类（定义于 `system/core/libutils/include/utils/Mutex.h`），它封装了 `pthread_mutex_t`，并提供自动加解锁的 `AutoLock` 辅助类。使用不当（如忘记解锁）...

pthread_mutex_lock造成死锁原因

10-21

7484

刚刚接触linux不久，在多线程编程时遇到了互斥锁死锁的情况，分析原因是同一个锁连续两次加锁，导致程序被锁死。

多线程编程中关于“死锁”的相关概念问题

日常记录，挨打要立正！

10-12

877

死锁的条件，与饥饿、死循环的异同，如何避免死锁

linux将程序锁死,Linux死锁现象及分析方法（转）

weixin_29216353的博客

05-04

1366

本节我们对Linux死锁做一个基本的介绍，然后讲解如何检测并定位死锁。1. 什么是死锁？死锁(DeadLock)是指两个或者两个以上的进程(线程)在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程(线程)称为死锁进程(线程)。由于资源占用是互斥的，当某个进程提出申请后，使得有关进程(线程)在无外力...

java迭代器创建后mutx锁,多线程操作C++ STL vector出现概率coredump问题及尽量避免锁的双缓冲队列...

weixin_39720003的博客

03-10

244

多线程操作全局变量，必须考虑同步问题，否则可能出现数据不一致，甚至触发coredump.前段时间，遇到一个多线程操作了全局的vector的问题, 程序崩了。场景是这样的：某全局配置参数保存在一个vector中，需要定时更新(更新线程)，另外的工作线程去读取配置。这种场景是非常普遍的。在该场景中，程序没有枷锁，概率coredump, 实际情况是，服务跑了一段时间后，必然coredump....

【转】pthread mutex 基本用法

sinolover的专栏

03-07

4275

转自：pthread mutex 基本用法 | feng 言 feng 语锁是程序中经常需要用到的机制，尤其是多线程的程序中，如果没有锁的帮助，线程间的同步就会非常麻烦甚至不可能。pthread中提供了mutex互斥量这种锁，在 linux 下经常用到，以下是pthread_mutex_t的相关函数介绍及简单用法。相关函数 1 2 3 4 5 6 7 8 9 10 #include <pthread.h> pthread_mutex_t m

Linux线程同步之互斥量加锁解锁pthread_mutex_init、pthread_mutex_destroy、pthread_mutex_lock、 pthread_mutex_unlock

l_z_y_000的博客

12-19

3668

Linux线程同步之互斥量加锁解锁pthread_mutex_init、pthread_mutex_destroy、pthread_mutex_lock、 pthread_mutex_unlock

linux内核互斥锁mutex实现详解(基于ARM处理器)