linux-C下的死锁检测（pthread_mutex_）

最新推荐文章于 2023-08-11 22:31:56 发布
最新推荐文章于 2023-08-11 22:31:56 发布
阅读量905 收藏
点赞数
分类专栏： C++/C
[cpp] view plain copy
print ?
  1. #include <stdio.h>  
  2. #include <stdlib.h>  
  3. #include <string.h>  
  4. #include <pthread.h>  
  5.   
  6. #define MAX_COUNT 64  
  7.   
  8. typedef struct tagMute   
  9. {  
  10.     pthread_mutex_t  mutex;  
  11.     char file[128];  
  12.     int  line;  
  13.     int  mute_status;  
  14.     struct tagPLAYER * tag_player;  
  15. } T_MUTE;  
  16.   
  17. typedef struct tagPLAYER  
  18. {  
  19.     T_MUTE *player_mux;  
  20. }T_PLAYER;  
  21.   
  22. typedef struct tagLIST  
  23. {  
  24.     int     list_count;  
  25.     T_MUTE *list[MAX_COUNT];  
  26. }T_LIST;  
  27.   
  28. typedef struct tagARG  
  29. {  
  30.   
  31.     int shareA, shareB;  
  32.     int count;  
  33.     T_PLAYER *player_A, *player_B;  
  34. }T_ARG;  
  35.   
  36. T_LIST *list;  
  37.   
  38. #define PLAYER_MUXTEX_INIT(x) do {\  
  39. T_PLAYER *player = (T_PLAYER *)x;\  
  40. pthread_mutex_init(&(player->player_mux->mutex), NULL);\  
  41. memset(player->player_mux->file, 0, sizeof(player->player_mux->file));\  
  42. player->player_mux->line = 0;\  
  43. player->player_mux->mute_status = 0;\  
  44. player->player_mux->tag_player = player;\  
  45. list->list[list->list_count++] = player->player_mux;\  
  46. }while(0)  
  47.   
  48. #define PLAYER_MUXTEX_LOCK(x) do {\  
  49.     T_PLAYER *player = (T_PLAYER *)x;\  
  50.     pthread_mutex_lock(&(player->player_mux->mutex));\  
  51.     strncpy(player->player_mux->file, __FILE__, sizeof(player->player_mux->file));\  
  52.     player->player_mux->line =  __LINE__;\  
  53.     player->player_mux->mute_status = 1;\  
  54. }while (0)  
  55.   
  56. #define PLAYER_MUXTEX_UNLOCK(x) do {\  
  57.     T_PLAYER *player = (T_PLAYER *)x;\  
  58.     player->player_mux->mute_status = 0;\  
  59.     pthread_mutex_unlock(&player->player_mux->mutex);\  
  60. }while(0)  
  61.   
  62. #define PLAYER_MUXTEX_DESTROY do {\  
  63.     while(list->list_count){\  
  64.         pthread_mutex_destroy(&list->list[list->list_count-1]->mutex);\  
  65.         free(list->list[list->list_count-1]);\  
  66.         list->list_count--;\  
  67.     }\  
  68. }while(0)  
  69.   
  70. void handle_dead_lock(void)  
  71. {  
  72.     int index;  
  73. flag:  
  74.     printf("Please input unlock index: ");  
  75.     scanf("%d", &index);  
  76.   
  77.     if((index >= 0) &&(index < list->list_count))  
  78.     {  
  79.         PLAYER_MUXTEX_UNLOCK(list->list[index]->tag_player);  
  80.     }  
  81.     else  
  82.     {  
  83.         printf("Input error!\n");  
  84.         goto flag;  
  85.     }  
  86. }  
  87.   
  88. void *loop_detect_deadlock_thread(void *arg)  
  89. {    
  90.     pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);  
  91.     pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, NULL);  
  92.   
  93.     T_ARG *argDetect = (T_ARG *)arg;  
  94.     int i = 0;  
  95.     while(1)  
  96.     {  
  97.         T_MUTE *mutex = list->list[i];  
  98.   
  99.         pthread_mutex_lock(&mutex->mutex);  
  100.         argDetect->count ++;  
  101.         pthread_mutex_unlock(&mutex->mutex);  
  102.   
  103.           
  104.         i = (++i) % list->list_count;  
  105.         pthread_testcancel();  
  106.         sleep(1);  
  107.     }  
  108. }  
  109.   
  110. void *loop_detect_count_thread(void *arg)  
  111. {  
  112.     pthread_setcancelstate(PTHREAD_CANCEL_ENABLE,NULL);  
  113.     pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS,NULL);  
  114.   
  115.     T_ARG *argCount = (T_ARG *)arg;  
  116.     do  
  117.     {  
  118.         int temp = argCount->count;  
  119.         sleep(5);  
  120.         if(temp == argCount->count)  
  121.         {  
  122.             printf("dead lock!\n");  
  123.             int i = 0;  
  124.             for(i = 0; i < list->list_count; i++)  
  125.             {  
  126.                 if(list->list[i]->mute_status)  
  127.                 {  
  128.                     printf("%d\tlock at %s:%d\n",i, list->list[i]->file, list->list[i]->line);  
  129.                 }  
  130.             }  
  131.             handle_dead_lock();  
  132.         }  
  133.     }while(1);  
  134. }  
  135.   
  136. void * thread_fun_A(void * arg)  
  137. {  
  138.     T_ARG *argA = (T_ARG *)arg;  
  139.     PLAYER_MUXTEX_LOCK(argA->player_A);  
  140.     printf("threadA lock   playerA, shareA = %d, shareB = %d\n", argA->shareA, argA->shareB);  
  141.   
  142. //    printf("shareA = shareA(%d) + 2\n", shareA);  
  143.     argA->shareA += 2;  
  144.       
  145.   
  146.     sleep(1);  
  147.     PLAYER_MUXTEX_LOCK(argA->player_B);  
  148.     printf("threadA lock   playerB, shareA = %d, shareB = %d\n", argA->shareA, argA->shareB);  
  149.   
  150. //    printf("shareA = shareB(%d) + 2\n", shareB);  
  151.     argA->shareA = argA->shareB + 2;  
  152.       
  153.       
  154.     PLAYER_MUXTEX_UNLOCK(argA->player_B);  
  155.     printf("threadA unlock playerB, shareA = %d, shareB = %d\n", argA->shareA, argA->shareB);  
  156.       
  157.     PLAYER_MUXTEX_UNLOCK(argA->player_A);  
  158.     printf("threadA unlock playerA, shareA = %d, shareB = %d\n", argA->shareA, argA->shareB);  
  159. }  
  160.   
  161. void * thread_fun_B(void * arg)  
  162. {  
  163.     T_ARG *argB = (T_ARG *)arg;  
  164.       
  165.     PLAYER_MUXTEX_LOCK(argB->player_B);  
  166.     printf("threadB lock   playerB, shareA = %d, shareB = %d\n", argB->shareA, argB->shareB);  
  167.   
  168. //    printf("shareB = shareB(%d) + 3\n", shareB);  
  169.     argB->shareB += 3;  
  170.       
  171.       
  172.     sleep(1);  
  173.     PLAYER_MUXTEX_LOCK(argB->player_A);  
  174.     printf("threadB lock   playerA, shareA = %d, shareB = %d\n", argB->shareA, argB->shareB);  
  175.   
  176. //    printf("shareB = shareA(%d) + 3\n", shareA);  
  177.     argB->shareB = argB->shareA + 3;  
  178.       
  179.       
  180.     PLAYER_MUXTEX_UNLOCK(argB->player_A);  
  181.     printf("threadB unlock playerA, shareA = %d, shareB = %d\n", argB->shareA, argB->shareB);  
  182.   
  183.     PLAYER_MUXTEX_UNLOCK(argB->player_B);  
  184.     printf("threadB unlock playerB, shareA = %d, shareB = %d\n", argB->shareA, argB->shareB);  
  185. }  
  186.   
  187. void init(T_ARG *arg)  
  188. {  
  189.     arg->shareA = 0;  
  190.     arg->shareB = 0;  
  191.     arg->count = 0;  
  192.   
  193.     list = (T_LIST *)malloc(sizeof(T_LIST));  
  194.     list->list_count = 0;  
  195.       
  196.     arg->player_A = (T_PLAYER *)malloc(sizeof(T_PLAYER));  
  197.     arg->player_B = (T_PLAYER *)malloc(sizeof(T_PLAYER));  
  198.   
  199.     arg->player_A->player_mux = (T_MUTE *)malloc(sizeof(T_MUTE));  
  200.     arg->player_B->player_mux = (T_MUTE *)malloc(sizeof(T_MUTE));  
  201.   
  202.     PLAYER_MUXTEX_INIT(arg->player_A);  
  203.     PLAYER_MUXTEX_INIT(arg->player_B);  
  204. }  
  205.   
  206. void free_player(T_ARG *arg)  
  207. {  
  208.     free(arg->player_A);  
  209.     free(arg->player_B);  
  210.       
  211.     free(arg);  
  212.   
  213.     free(list);  
  214. }  
  215. int main(int argc, char * argv[])  
  216. {  
  217.     T_ARG *arg = (T_ARG *)malloc(sizeof(T_ARG));  
  218.       
  219.     init(arg);  
  220.       
  221.     int ret = -1;  
  222.       
  223.     pthread_t threadA, threadB, thread_detect_deadlock, thread_detect_count;  
  224.     ret = pthread_create(&threadA, NULL, thread_fun_A, (void *)arg);   
  225.     if(ret != 0)  
  226.     {  
  227.         printf("Pthread create error!\n");  
  228.     }  
  229.   
  230.     ret = pthread_create(&threadB, NULL, thread_fun_B, (void *)arg);   
  231.     if(ret != 0)  
  232.     {  
  233.         printf("Pthread create error!\n");  
  234.     }  
  235.   
  236.     ret = pthread_create(&thread_detect_deadlock, NULL, loop_detect_deadlock_thread, (void *)arg);   
  237.     if(ret != 0)  
  238.     {  
  239.         printf("Pthread create error!\n");  
  240.     }  
  241.   
  242.     ret = pthread_create(&thread_detect_count, NULL, loop_detect_count_thread, (void *)arg);   
  243.     if(ret != 0)  
  244.     {  
  245.         printf("Pthread create error!\n");  
  246.     }  
  247.       
  248.     pthread_join(threadA, NULL);  
  249.     pthread_join(threadB, NULL);  
  250.   
  251.     pthread_cancel(thread_detect_count);  
  252.     pthread_cancel(thread_detect_deadlock);  
  253.     pthread_join(thread_detect_count, NULL);  
  254.     pthread_join(thread_detect_deadlock, NULL);  
  255.       
  256.     PLAYER_MUXTEX_DESTROY;  
  257.   
  258.     printf("shareA: %d, shareB: %d\n", arg->shareA, arg->shareB);  
  259.     free_player(arg);  
  260. }  
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>

#define MAX_COUNT 64

typedef struct tagMute 
{
    pthread_mutex_t  mutex;
    char file[128];
    int  line;
    int  mute_status;
    struct tagPLAYER * tag_player;
} T_MUTE;

typedef struct tagPLAYER
{
    T_MUTE *player_mux;
}T_PLAYER;

typedef struct tagLIST
{
    int     list_count;
    T_MUTE *list[MAX_COUNT];
}T_LIST;

typedef struct tagARG
{

    int shareA, shareB;
    int count;
    T_PLAYER *player_A, *player_B;
}T_ARG;

T_LIST *list;

#define PLAYER_MUXTEX_INIT(x) do {\
T_PLAYER *player = (T_PLAYER *)x;\
pthread_mutex_init(&(player->player_mux->mutex), NULL);\
memset(player->player_mux->file, 0, sizeof(player->player_mux->file));\
player->player_mux->line = 0;\
player->player_mux->mute_status = 0;\
player->player_mux->tag_player = player;\
list->list[list->list_count++] = player->player_mux;\
}while(0)

#define PLAYER_MUXTEX_LOCK(x) do {\
    T_PLAYER *player = (T_PLAYER *)x;\
    pthread_mutex_lock(&(player->player_mux->mutex));\
    strncpy(player->player_mux->file, __FILE__, sizeof(player->player_mux->file));\
    player->player_mux->line =  __LINE__;\
    player->player_mux->mute_status = 1;\
}while (0)

#define PLAYER_MUXTEX_UNLOCK(x) do {\
    T_PLAYER *player = (T_PLAYER *)x;\
    player->player_mux->mute_status = 0;\
    pthread_mutex_unlock(&player->player_mux->mutex);\
}while(0)

#define PLAYER_MUXTEX_DESTROY do {\
    while(list->list_count){\
        pthread_mutex_destroy(&list->list[list->list_count-1]->mutex);\
        free(list->list[list->list_count-1]);\
        list->list_count--;\
    }\
}while(0)

void handle_dead_lock(void)
{
    int index;
flag:
    printf("Please input unlock index: ");
    scanf("%d", &index);

    if((index >= 0) &&(index < list->list_count))
    {
        PLAYER_MUXTEX_UNLOCK(list->list[index]->tag_player);
    }
    else
    {
        printf("Input error!\n");
        goto flag;
    }
}

void *loop_detect_deadlock_thread(void *arg)
{  
    pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
    pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, NULL);

    T_ARG *argDetect = (T_ARG *)arg;
    int i = 0;
    while(1)
    {
        T_MUTE *mutex = list->list[i];

        pthread_mutex_lock(&mutex->mutex);
        argDetect->count ++;
        pthread_mutex_unlock(&mutex->mutex);

        
        i = (++i) % list->list_count;
        pthread_testcancel();
        sleep(1);
    }
}

void *loop_detect_count_thread(void *arg)
{
    pthread_setcancelstate(PTHREAD_CANCEL_ENABLE,NULL);
    pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS,NULL);

    T_ARG *argCount = (T_ARG *)arg;
    do
    {
        int temp = argCount->count;
        sleep(5);
        if(temp == argCount->count)
        {
            printf("dead lock!\n");
            int i = 0;
            for(i = 0; i < list->list_count; i++)
            {
                if(list->list[i]->mute_status)
                {
                    printf("%d\tlock at %s:%d\n",i, list->list[i]->file, list->list[i]->line);
                }
            }
            handle_dead_lock();
        }
    }while(1);
}

void * thread_fun_A(void * arg)
{
    T_ARG *argA = (T_ARG *)arg;
    PLAYER_MUXTEX_LOCK(argA->player_A);
    printf("threadA lock   playerA, shareA = %d, shareB = %d\n", argA->shareA, argA->shareB);

//    printf("shareA = shareA(%d) + 2\n", shareA);
    argA->shareA += 2;
    

    sleep(1);
    PLAYER_MUXTEX_LOCK(argA->player_B);
    printf("threadA lock   playerB, shareA = %d, shareB = %d\n", argA->shareA, argA->shareB);

//    printf("shareA = shareB(%d) + 2\n", shareB);
    argA->shareA = argA->shareB + 2;
    
    
    PLAYER_MUXTEX_UNLOCK(argA->player_B);
    printf("threadA unlock playerB, shareA = %d, shareB = %d\n", argA->shareA, argA->shareB);
    
    PLAYER_MUXTEX_UNLOCK(argA->player_A);
    printf("threadA unlock playerA, shareA = %d, shareB = %d\n", argA->shareA, argA->shareB);
}

void * thread_fun_B(void * arg)
{
    T_ARG *argB = (T_ARG *)arg;
    
    PLAYER_MUXTEX_LOCK(argB->player_B);
    printf("threadB lock   playerB, shareA = %d, shareB = %d\n", argB->shareA, argB->shareB);

//    printf("shareB = shareB(%d) + 3\n", shareB);
    argB->shareB += 3;
    
    
    sleep(1);
    PLAYER_MUXTEX_LOCK(argB->player_A);
    printf("threadB lock   playerA, shareA = %d, shareB = %d\n", argB->shareA, argB->shareB);

//    printf("shareB = shareA(%d) + 3\n", shareA);
    argB->shareB = argB->shareA + 3;
    
    
    PLAYER_MUXTEX_UNLOCK(argB->player_A);
    printf("threadB unlock playerA, shareA = %d, shareB = %d\n", argB->shareA, argB->shareB);

    PLAYER_MUXTEX_UNLOCK(argB->player_B);
    printf("threadB unlock playerB, shareA = %d, shareB = %d\n", argB->shareA, argB->shareB);
}

void init(T_ARG *arg)
{
    arg->shareA = 0;
    arg->shareB = 0;
    arg->count = 0;

    list = (T_LIST *)malloc(sizeof(T_LIST));
    list->list_count = 0;
    
    arg->player_A = (T_PLAYER *)malloc(sizeof(T_PLAYER));
    arg->player_B = (T_PLAYER *)malloc(sizeof(T_PLAYER));

    arg->player_A->player_mux = (T_MUTE *)malloc(sizeof(T_MUTE));
    arg->player_B->player_mux = (T_MUTE *)malloc(sizeof(T_MUTE));

    PLAYER_MUXTEX_INIT(arg->player_A);
    PLAYER_MUXTEX_INIT(arg->player_B);
}

void free_player(T_ARG *arg)
{
    free(arg->player_A);
    free(arg->player_B);
    
    free(arg);

    free(list);
}
int main(int argc, char * argv[])
{
    T_ARG *arg = (T_ARG *)malloc(sizeof(T_ARG));
    
    init(arg);
    
    int ret = -1;
    
    pthread_t threadA, threadB, thread_detect_deadlock, thread_detect_count;
    ret = pthread_create(&threadA, NULL, thread_fun_A, (void *)arg); 
    if(ret != 0)
    {
        printf("Pthread create error!\n");
    }

    ret = pthread_create(&threadB, NULL, thread_fun_B, (void *)arg); 
    if(ret != 0)
    {
        printf("Pthread create error!\n");
    }

    ret = pthread_create(&thread_detect_deadlock, NULL, loop_detect_deadlock_thread, (void *)arg); 
    if(ret != 0)
    {
        printf("Pthread create error!\n");
    }

    ret = pthread_create(&thread_detect_count, NULL, loop_detect_count_thread, (void *)arg); 
    if(ret != 0)
    {
        printf("Pthread create error!\n");
    }
    
    pthread_join(threadA, NULL);
    pthread_join(threadB, NULL);

    pthread_cancel(thread_detect_count);
    pthread_cancel(thread_detect_deadlock);
    pthread_join(thread_detect_count, NULL);
    pthread_join(thread_detect_deadlock, NULL);
    
    PLAYER_MUXTEX_DESTROY;

    printf("shareA: %d, shareB: %d\n", arg->shareA, arg->shareB);
    free_player(arg);
}
[cpp] view plain copy
print ?
  1. 有什么不明白的可以留言~看到了就回~  
有什么不明白的可以留言~看到了就回~



明潮
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
用C语言实现死锁检测.rar_c语言判断死锁_deadlock_死锁_死锁 检测_死锁c语言
09-20
用C语言实现死锁检测
linux C语言 多线程竞争（加锁解锁 pthread_mutex_t、pthread_mutex_lock()、pthread_mutex_unlock() 可解决）
Dontla的博客
07-25 1454
线程在短时间内对相同内存单元进行操作时，如果不加锁解锁，有可能产生线程竞争的情况，即最终结果不符合预期。
Linux C 互斥锁的使用
热门推荐
哈哈一笑
06-13 2万+
互斥锁的作用 保护共享数据： 在并发机制的情况下，有时候会有多个线程同时访问同一片数据，为了保护数据操作的准确性就需要通过加锁来进行保护。 保持操作互斥： 可能一个程序会有多个操作，但是同一个时间只能有一个操作被执行，例如a/b两个操作，如果a被执行,b就不能被执行，同理b被执行，a就不能执行 操作函数 pthread_mutex_t lock; /* 互斥锁定义 */ pthread_mute...
操作系统 MIT 6.S081
最新发布
qq_42865685的博客
08-11 372
MIT 6.S081 课程和实验0 准备实验环境搭建git使用1 lab12 Lab2 system calls2.1 System call tracing（moderate）2.1.1 实验要求2.1.2 实验解决代码2.2 Sysinfo（moderate）2.2.1 实验要求2.2.2 实验解决代码3 Lab3: page tables3.1 前置知识：虚拟页表3.2 Print a page table (easy)（编写一个打印页表内容的函数）3.2.1 实验要求3.2.2 实验解决代码3.3
linux 查询死锁进程,Linux 的死锁检测--这篇文章值得看~
weixin_28916817的博客
04-29 875
原标题：Linux 的死锁检测--这篇文章值得看~死锁死锁：就是多个进程(≥2)因为争夺资源而相互等待的一种现象，若无外力推动，将无法继续运行下去。注意，只有在多进程或者多线程之间或者他们与中断之间相互通讯或者共享资源才有可能发生死锁，单线程或者进程之间没有联系的话，一般不会发生死锁。锁的种类比较多，这里主要说自旋锁和信号量。两者的差别就在于前者获得不到资源时的动作是不断的资源(即忙转浪费 cpu...
pthread_mutex_t_is_too_small_for_large_pids_in_aosp_bionic.patch
03-13
32位android中bionic是32位的，其中的mutex只有一半也就是16位能够存储pid，当通过docker运行android时，大概率pid会超过16位的范围，就可能会导致android中mutex死锁，表现为应用卡住黑屏。 [32-bit ABI bugs]...
死锁检测算法C++.rar_VC 死锁_Vc_c++检测死锁_死锁_死锁的检测
09-19
操作系统的死锁检测算法， VC++调试通过
Java-for-thread.zip_java 线程
09-24
Java多线程,进程与线程概念 创建和启动Java线程 线程状态和线程控制 多线程的互斥与同步 线程的通讯 死锁的概念
SQL2005查看死锁存储过程sp_who_lock
09-10
本文分享一个查看死锁的存储过程，方便技术人员查找产生死锁的原因。
内存溢出，死锁怎么办？教你如何排查
Snow__Sunny的博客
09-28 1619
原文：https://mp.weixin.qq.com/s/U4PkvzNYCkgPrLWg8LTdYA 在Linux上编写运行C语言程序，经常会遇到程序崩溃、卡死等异常的情况程序崩溃时最常见的就是程序运行终止，报告Segmentation fault (core dumped)错误。而程序卡死一般来源于代码逻辑的缺陷，导致了死循环、死锁等问题。总的来看，常见的程序异常问题一般可以分为非法内存访问和资源访问冲突两大类。 非法内存访问（读/写）：非法指针、多线程共享数据访问冲突、内存访问越界、缓冲
读写锁排查思路
FirMoonLight的博客
09-02 189
表示没有线程持有读锁，也没有线程持有写锁，但是读写锁的值却异常了。只有两种可能，一是未初始化，二是内存被改写。走查代码，发现两个构造函数中，只有一个构造函数初始化了读写锁。从读写锁的逻辑看出，如果在读锁加锁的时候，不为0，那么就会阻塞读锁。
Linux死锁检测和解决
weixin_43155199的博客
04-08 768
创作人QQ：851301776，邮箱：[email protected]， 欢迎大家一起技术交流，本博客主要是自己学习的心得体会,只为每天进步一点点！ 个人座右铭： 1.没有横空出世，只要厚积一定发。 2.你可以学历不高，你可以不上学，但你不能不学习 一、死锁存在的条件 死锁，是指多个线程或者进程在运行过程中因争夺资源而造成的一种僵局，当进程或者线程 处于这种僵持状态，若无外力作用，它们将无法再向前推进。如下图所示，线程 A 想获取线程 B 的锁，线程 B 想获取线程 C 的锁...
Linux——死锁概念介绍和解决方式
weixin_61857742的博客
02-03 1793
死锁指的是在多线程环境中，每个执行流（线程）都有未释放的资源，且互相请求对方未释放资源，从而导致陷入永久等待状态的情况。就好比和绑匪交赎金时，家属要求先放人再给钱，绑匪要求先交钱再给人，双方达不成一致意见，导致出现“僵死”的局面。程序层面而言，两个线程各加一个互斥锁mutex，在临界区中试图获取对方的互斥锁，陷入“互相请求对方的锁，但不释放自己锁”的尴尬局面，这就是死锁的一种场景。同一时间只能有一个执行流拥有资源执行流请求资源时，不能释放已有资源执行流已有资源不能被强制剥夺。
linux的mutex状态查询命令,Linux C 互斥量mutex 使用记录
weixin_35391606的博客
05-12 533
一、互斥量 Mutex 主要包含一下几个函数：1、int pthread_mutex_init (pthread_mutex_t *mutex, const pthread_mutexattr_t *attr);初始化一个mutex，如果attr为NULL测按默认值初始化，另外还可以在定义互斥量的时候按照下面的方式初始化一个互斥量：pthread_mutex_t mutex = PTHREAD_M...
Linux线程同步之互斥量加锁解锁pthread_mutex_init、pthread_mutex_destroy、pthread_mutex_lock、 pthread_mutex_unlock
l_z_y_000的博客
12-19 2499
Linux线程同步之互斥量加锁解锁pthread_mutex_init、pthread_mutex_destroy、pthread_mutex_lock、 pthread_mutex_unlock
glibc: pthread: pthread_mutex_lock 返回值的判断，pthread_cond_wait
mzhan017的博客
01-27 475
从上面的使用说明上看，在调用pthread_cond_wait之前，需要确保，mutex已经lock了。如果调用这个函数的时候，不能确定mutex已经lock。可能会出现未定义的行为。潜在会留下一些问题，但是不一定什么时候出现，这就为问题调试埋下了隐患。
互斥锁pthread_mutex_t的使用
fullinhouse818的专栏
05-10 786
<br />1. 互斥锁创建<br />        有两种方法创建互斥锁，静态方式和动态方式。POSIX定义了一个宏PTHREAD_MUTEX_INITIALIZER来静态初始化互斥锁，方法如下： <br />              pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;<br />              在LinuxThreads实现中，pthread_mutex_t是一个结构，而PTHREAD_MUTEX_INITIALIZER则是一
掌握死锁检测：策略和最佳实践
Lion_Long的博客
09-25 815
死锁的产生是因为多线程之间存在交叉申请锁的情况，因争夺资源而造成的一种僵局。hook使用：（1）定义与目标函数一样的类型；（2）具体函数实现，函数名与目标函数名一致；（3）调用dlsym()函数，初始化hook。死锁检测可以使用图算法，通过检测有向图是否有环判断是否有死锁。
pthread_mutex_lock和pthread_mutex_unlock作用及例程详解
06-09
pthread_mutex_lock和pthread_mutex_unlock是用于线程同步的函数。线程同步是指多个线程按照一定的顺序执行，以避免竞态条件和死锁等问题。 pthread_mutex_lock函数用于获取一个互斥锁，如果该互斥锁已经被其他线程...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值