实验 Linux死锁现象及分析【操作系统】

最新推荐文章于 2023-10-17 10:34:59 发布
最新推荐文章于 2023-10-17 10:34:59 发布
阅读量1.1k 收藏 15
点赞数 2
分类专栏： # 操作系统 文章标签： linux 运维 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51625007/article/details/124878771
版权

实验 Linux死锁现象及分析【操作系统】

Linux死锁现象及分析

1. 什么是死锁？

死锁（DeadLock)是指两个或者两个以上的进程（线程）在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程（线程）称为死锁进程(线程）。由于资源占用是互斥的，当某个进程提出申请后，使得有关进程（线程）在无外力协助下，永远分配不到必需的资源而无法继续进行，这就产生了一种特殊现象——死锁。

一种交叉持锁死锁的情形，此时执行程序中两个或多个线程发生永久堵塞（等待），每个线程都在等待被其他线程占用并堵塞了的资源。例如，如果线程1锁住了记录A并等待记录B，而线程2锁住了记录B并等待记录A，这样两个线程就发生了死锁现象。在计算机系统中，如果系统的资源分配策略不当，更常见的可能是程序员写的程序有错误等，则会导致进程因竞争资源不当而产生死锁的现象。

2. 产生死锁的四个必要条件

1）对临界资源的互斥使用(资源独占）

一个资源每次只能给一个进程（线程）使用。比如写操作

2） 占有且等待

进程在申请新的资源的同时，保持对原有资源的占有。

3） 不可抢占

资源申请者不能强行从资源占有者手中夺取资源，资源只能由占有者自愿释放。

4）循环等待

P1等待P2占有的资源，P2等待P3占有的资源， …， Pn等待P1占有的资源，形成一个进程等待回路。

3. 死锁避免、银行家算法

请参看操作系统linux：银行家算法（C语言实现）

4. 实战

1.运行第三步中的代码实例，验证不同情况下的资源请求，系统是否安全。对程序进行修改，要求在判断到系统处于安全状态后，还需输出安全序列。

2.在进程同步的实验中，关于生产者和消费者问题，编写可以产生死锁的程序，运行后对结果加以分析。

银行家算法【源程序】

代码

banker.c

#include<stdio.h>
#include<stdlib.h>
int main()
{
    int  n ,m,t,w,flag1=1,flag2=1,flag4=1,flag5=1;
    int*Available,*Request,*Finish;
    int **Allocation,**Max,**Need,**Work;
    FILE*fp;
    fp=fopen("/root/os/jsss-12/data.txt","r");                   //打开.txt文件
    fscanf(fp,"%d",&n),fscanf(fp,"%d",&m);                 //赋值.txt文件的数值，n*m二维数组
    Available = (int*)malloc(sizeof(int)*m);                                  //开动态一维数组
    for(int i=0;i<m;i++)                                                         //给一维数组赋值
        fscanf(fp,"%d",&Available[i]);
    Allocation= (int**)malloc(sizeof(int*)*n);               //开动态二维数组
    Max= (int**)malloc(sizeof(int*)*n); 
    Need= (int**)malloc(sizeof(int*)*n); 
    for (int i = 0; i < n; i++)
         {
            Allocation[i] = (int*)malloc(sizeof(int)*m);
            Max[i] = (int*)malloc(sizeof(int)*m);
            Need[i] = (int*)malloc(sizeof(int)*m);
         }
    for(int i=0;i<n;i++)                       //给二维数组赋值
        {
            fscanf(fp,"%d",&t);               //t为进程编号
            for(int j=0;j<m;j++)
                fscanf(fp,"%d",&Allocation[t][j]);
            for(int  j=0;j<m;j++)
                fscanf(fp,"%d",&Max[t][j]);
            for(int j=0;j<m;j++)
                Need[i][j]=Max[i][j]-Allocation[i][j];
        }
     for(int i=0;i<m;i++)
        for(int j=0;j<n;j++)
                Available[i]-=Allocation[j][i];
    fscanf(fp,"%d",&w);             //w为发出请求的进程的编号
    Request = (int*)malloc(sizeof(int)*m);
    for(int i=0;i<m;i++)
            fscanf(fp,"%d",&Request[i]);
    for(int i=0;i<m;i++)
        if(Request[i]>Need[w][i])
            flag1=0; 
    if(!flag1)                       //flag1用来判断Request是否小于等于Need
        printf("Flase\n");
    else {
        for(int i=0;i<m;i++)
            if(Request[i]>Available[i])
                flag2=0; 
        if(!flag2)                          //flag2用来判断Request是否小于等于Available
            printf("p %d 等待\n",w);
        else {
            for(int i=0;i<m;i++)             //假设系统把申请的资源分给进程
                {
                    Available[i]-=Request[i];
                    Allocation[w][i]+=Request[i];
                    Need[w][i]-=Request[i];
                }
            Work= (int**)malloc(sizeof(int*)*n);
            for (int i = 0; i < n; i++)
                Work[i] = (int*)malloc(sizeof(int)*m);
            Finish = (int*)malloc(sizeof(int)*n);
            for(int i=0;i<n;i++)
                Finish[i]=0;                     //fnish[i]=0代表fnish[i]=flase，fnish[i]=1代表fnish[i]=true
            for(int i=0;i<n;i++)
                for(int j=0;j<m;j++)
                        Work[i][j]=Available[j];
            while(flag5)               //安全性算法，flag5用来判断系统是否已经完成安全性判断
                {
                    for(int i=0;i<n;i++)                //每次从0号进程开始搜索是否有满足条件的进程
                        {
                            int flag3=1;                             //flag3用来判断Need是否小于等于Work
                            for(int j=0;j<m;j++)
                                   if(Need[i][j]>Work[i][j])
                                        flag3=0;
                            if(!Finish[i]&&flag3)            //找到满足Finish[i]=false且Need小于等于Work
                            {
                                Finish[i]=1;                            //置Finish[i]=true
                                for(int j=0;j<n;j++)                   //释放进程所占全部资源
                                    for(int k=0;k<m;k++)
                                        if(j!=i&&!Finish[j])
                                               Work[j][k]=Work[i][k]+Allocation[i][k];
                                break;
                            }
                            else if(i==n-1)                        //没有找到满足条件的并且是最后一个进程
                            {
                                    for(int j=0;j<n;j++)
                                        if(!Finish[j])
                                            flag4=0; 
                                    if(flag4)                       //flag4用来判断是否所有进程都是Finish[i]=true
                                    {
                                        printf("系统处于安全状态\n");
                                        printf("Work:\n");
                                        for(int j=0;j<n;j++)              //输出安全状态下，系统把申请的资源分配给进程资源的情况
                                            {
                                                for(int k=0;k<m;k++)
                                                printf("%4d",Work[j][k]);
                                                printf("\n");
                                            }
                                        printf("Alllcation:\n");
                                        for(int j=0;j<n;j++)
                                            {
                                                for(int k=0;k<m;k++)
                                                printf("%4d",Allocation[j][k]);
                                                printf("\n");
                                            }
                                        printf("Need:\n");
                                        for(int j=0;j<n;j++)
                                            {
                                                for(int k=0;k<m;k++)
                                                printf("%4d",Need[j][k]);
                                                printf("\n");
                                            }
                                        printf("Available:\n");
                                        for(int j=0;j<m;j++)
                                            printf("%4d",Work[n-1][j]+Allocation[n-1][j]);
							printf("\n");
                                        flag5=0;
                                    }
                                    else{
                                        printf("系统处于不安全状态\n");
                                        for(int j=0;j<m;j++)             //系统不安全，还原资源分配给进程前的情况
                                            {
                                                Available[j]+=Request[j];
                                                Allocation[w][j]-=Request[j];
                                                Need[w][j]+=Request[j];
                                            }
                                        flag5=0;
                                    }
                            }
                        }
                }
        }
    }
}

运行结果

data.txt 说明
验证数据：建立在程序目录下建立data文件，文件内容是：
5 3
10 5 7
0 0 1 0 7 5 3
1 2 0 0 3 2 2
2 3 0 2 9 0 2
3 2 1 1 2 2 2
4 0 0 2 4 3 3
1 1 0 2
4 3 3 0
0 0 2 0
第一行：5个进程，3种资源。
第二行：每种资源系统拥有的最大数量。
3-7行：第一列是进程号（按顺序排），2-4列是Allocation（已有资源）向量，5-7列是Max（最大资源需求量）向量。
8-10行：第一列是进程号，2-4列是Request（资源请求）向量。
运行程序，通过命令行参数指定文件，如： ./banker ./data运行。

fp=fopen("/home/student/data.txt","r");                   //打开.txt文件
//改成自己data.txt所在的绝对路径
fp=fopen("/root/os/jsss-12/data.txt","r");                   //打开.txt文件

[root@centos-7 jsss-12]# ls
banker  banker.c  data.txt
[root@centos-7 jsss-12]# pwd
/root/os/jsss-12

开始验证
1.验证第一个资源请求
//data.txt.文件

5 3
10 5 7
0 0 1 0 7 5 3
1 2 0 0 3 2 2
2 3 0 2 9 0 2
3 2 1 1 2 2 2
4 0 0 2 4 3 3
1 1 0 2

输出结果：
在这里插入图片描述

2.验证第二个资源请求
/data.txt文件/

5 3
10 5 7
0 0 1 0 7 5 3
1 2 0 0 3 2 2
2 3 0 2 9 0 2
3 2 1 1 2 2 2
4 0 0 2 4 3 3
4 3 3 0

输出结果：
在这里插入图片描述

3.验证第三个资源请求
/data.txt文件/

5 3
10 5 7
0 0 1 0 7 5 3
1 2 0 0 3 2 2
2 3 0 2 9 0 2
3 2 1 1 2 2 2
4 0 0 2 4 3 3
0 0 2 0

输出结果：

在这里插入图片描述

4.验证资源请求出错（即Request i>Need i）
/data.txt文件/

5 3
10 5 7
0 0 1 0 7 5 3
1 2 0 0 3 2 2
2 3 0 2 9 0 2
3 2 1 1 2 2 2
4 0 0 2 4 3 3
3 0 2 1

输出结果：
在这里插入图片描述

5.验证进程资源请求等待（即Request i>Available）
/data.txt文件/

5 3
10 5 7
0 0 1 0 7 5 3
1 2 0 0 3 2 2
2 3 0 2 9 0 2
3 2 1 1 2 2 2
4 0 0 2 4 3 3
0 4 4 3

输出结果：

在这里插入图片描述

输出安全序列【改进程序 】

代码

新增变量


//list数组用来存放安全序列
 int *list;//安全序列 
 list=(int*)malloc(sizeof(int)*n);
     for(int i=0;i<n;i++)     //给安全序列赋值                                                 
          list[i]=0;
    
//l变量来移动赋值list
int l=0;//用来移动 list

新增语句
在if(!Finish[i]&&flag3) 添加赋值语句list[l++]=i;
在if(flag4)中添加输出语句

printf("安全序列\n");
for(int i=0;i<n;i++)
 	printf("%4d",list[i]);
printf("\n");

banker2.c

#include<stdio.h>
#include<stdlib.h>
int main()
{
    int  n ,m,t,w,flag1=1,flag2=1,flag4=1,flag5=1;
    int*Available,*Request,*Finish;
    int **Allocation,**Max,**Need,**Work;

    int *list;//安全序列   
    FILE*fp;
    fp=fopen("/root/os/jsss-12/data.txt","r");                   //打开.txt文件
    fscanf(fp,"%d",&n),fscanf(fp,"%d",&m);                 //赋值.txt文件的数值，n*m二维数组
    Available = (int*)malloc(sizeof(int)*m);                                  //开动态一维数组 
    for(int i=0;i<m;i++)                                                         //给一维数组赋值
        fscanf(fp,"%d",&Available[i]);
    Allocation= (int**)malloc(sizeof(int*)*n);               //开动态二维数组
    Max= (int**)malloc(sizeof(int*)*n); 
    Need= (int**)malloc(sizeof(int*)*n); 

	 list=(int*)malloc(sizeof(int)*n);
     for(int i=0;i<n;i++)     //给安全序列赋值                                                 
          list[i]=0;
    int l=0;//用来移动 list

    for (int i = 0; i < n; i++)
         {
            Allocation[i] = (int*)malloc(sizeof(int)*m);
            Max[i] = (int*)malloc(sizeof(int)*m);
            Need[i] = (int*)malloc(sizeof(int)*m);
         }
    for(int i=0;i<n;i++)                       //给二维数组赋值
        {
            fscanf(fp,"%d",&t);               //t为进程编号
            for(int j=0;j<m;j++)
                fscanf(fp,"%d",&Allocation[t][j]);
            for(int  j=0;j<m;j++)
                fscanf(fp,"%d",&Max[t][j]);
            for(int j=0;j<m;j++)
                Need[i][j]=Max[i][j]-Allocation[i][j];
        }
     for(int i=0;i<m;i++)
        for(int j=0;j<n;j++)
                Available[i]-=Allocation[j][i];
    fscanf(fp,"%d",&w);             //w为发出请求的进程的编号
    Request = (int*)malloc(sizeof(int)*m);
    for(int i=0;i<m;i++)
            fscanf(fp,"%d",&Request[i]);
    for(int i=0;i<m;i++)
        if(Request[i]>Need[w][i])
            flag1=0; 
    if(!flag1)                       //flag1用来判断Request是否小于等于Need
        printf("Flase\n");
    else {
        for(int i=0;i<m;i++)
            if(Request[i]>Available[i])
                flag2=0; 
        if(!flag2)                          //flag2用来判断Request是否小于等于Available
            printf("p %d 等待\n",w);
        else {
            for(int i=0;i<m;i++)             //假设系统把申请的资源分给进程
                {
                    Available[i]-=Request[i];
                    Allocation[w][i]+=Request[i];
                    Need[w][i]-=Request[i];
                }
            Work= (int**)malloc(sizeof(int*)*n);
            for (int i = 0; i < n; i++)
                Work[i] = (int*)malloc(sizeof(int)*m);
            Finish = (int*)malloc(sizeof(int)*n);
            for(int i=0;i<n;i++)
                Finish[i]=0;                     //fnish[i]=0代表fnish[i]=flase，fnish[i]=1代表fnish[i]=true
            for(int i=0;i<n;i++)
                for(int j=0;j<m;j++)
                        Work[i][j]=Available[j];
            while(flag5)               //安全性算法，flag5用来判断系统是否已经完成安全性判断
                {
                    for(int i=0;i<n;i++)                //每次从0号进程开始搜索是否有满足条件的进程
                        {
                            int flag3=1;                             //flag3用来判断Need是否小于等于Work
                            for(int j=0;j<m;j++)
                                   if(Need[i][j]>Work[i][j])
                                        flag3=0;
                            if(!Finish[i]&&flag3)            //找到满足Finish[i]=false且Need小于等于Work
                            {
					list[l++]=i;
                                Finish[i]=1;                            //置Finish[i]=true
                                for(int j=0;j<n;j++)                   //释放进程所占全部资源
                                    for(int k=0;k<m;k++)
                                        if(j!=i&&!Finish[j])
                                               Work[j][k]=Work[i][k]+Allocation[i][k];
                                break;
                            }
                            else if(i==n-1)                        //没有找到满足条件的并且是最后一个进程
                            {
                                    for(int j=0;j<n;j++)
                                        if(!Finish[j])
                                            flag4=0; 
                                    if(flag4)                       //flag4用来判断是否所有进程都是Finish[i]=true
                                    {
                                        printf("系统处于安全状态\n");
                                        printf("Work:\n");
                                        for(int j=0;j<n;j++)              //输出安全状态下，系统把申请的资源分配给进程资源的情况
                                            {
                                                for(int k=0;k<m;k++)
                                                printf("%4d",Work[j][k]);
                                                printf("\n");
                                            }
                                        printf("Alllcation:\n");
                                        for(int j=0;j<n;j++)
                                            {
                                                for(int k=0;k<m;k++)
                                                printf("%4d",Allocation[j][k]);
                                                printf("\n");
                                            }
                                        printf("Need:\n");
                                        for(int j=0;j<n;j++)
                                            {
                                                for(int k=0;k<m;k++)
                                                printf("%4d",Need[j][k]);
                                                printf("\n");
                                            }
                                        printf("Available:\n");
                                        for(int j=0;j<m;j++)
                                            printf("%4d",Work[n-1][j]+Allocation[n-1][j]);
						printf("\n");
	
						printf("安全序列\n");
						for(int i=0;i<n;i++)
						    printf("%4d",list[i]);
					  	printf("\n");
                                        flag5=0;
                                    }
                                    else{
                                        printf("系统处于不安全状态\n");
                                        for(int j=0;j<m;j++)             //系统不安全，还原资源分配给进程前的情况
                                            {
                                                Available[j]+=Request[j];
                                                Allocation[w][j]-=Request[j];
                                                Need[w][j]+=Request[j];
                                            }
                                        flag5=0;
                                    }
                            }
                        }
                }
        }
    }
}

运行结果

1
在这里插入图片描述
3
在这里插入图片描述

日星月云
关注
  • 2
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
实验5_华工操作系统实验五_
10-02
华工计科实验5，实现银行家算法，解决死锁，包含样例
操作系统实验六 死锁问题实验
05-14
操作系统实验六：死锁问题实验报告。通过本实验观察死锁产生的现象，考虑解决死锁问题的方法。从而进一步加深对于死锁问题的理解。掌握解决死锁问题的几种算法的编程和调试技术。练习怎样构造管程和条件变量，利用管程机制来避免死锁和饥俄问题的发生。
linux_20个经典实验
12-03
linux_20个经典实验，里面的内容还不错，自己实习了下，适合初学者
操作系统实验二（死锁）
03-23
上海大学操作系统实验二（死锁）
操作系统实验报告死锁的检测与解除
06-09
操作系统实验报告死锁的检测与解除
linux 死锁概念
05-30
进一步解释了linux系统中关于死锁的知识点，让大家更容易理解
Linux - 死锁现象
dengnv0445的博客
08-04 283
一、死锁的概念： 　　1、死锁的现象描述： 　　　　在很多应用中，需要一个进程排他性的访问若干种资源而不是一种。例如，两个进程准备分别将扫描的文档记录到CD上。进程A请求使用扫描仪， 并被授权使用。但进程B首先请求CD刻录机，也被授权使用。这时，A请求使用CD刻录机，但这个请求在B释放CD刻录机前会被拒绝。但是，进程B非但 不会释放CD刻录机，还去请求扫描仪。这时，两个进程僵持不...
LINUX之死锁
time的博客
06-21 263
一 死锁的概念 死锁是指多个进程因竞争资源而造成的一种僵局（互相等待），若无外力作用，这些进程都将无法向前推进。 最简单、最好构造的死锁就是下图这种场景了。 说明： 线程1已经成功拿到互斥量1，正在申请互斥量2，而同时在另一个CPU上，线程2已经拿到了互斥量2，正在申请互斥量1。彼此占有对方正在申请的互斥量，结局就是谁也没有办法拿到想要的互斥量，于是就发生了死锁现象。二 死锁产
Linux之死锁
ww020202的博客
06-07 584
死锁的概念：         死锁可以被定义为一组相互竞争系统资源或进行通信的进程间“永久”阻塞。当一组进程的每个进程都在等待某个事件，而只有在这组进程中的其他被阻塞的进程才可以触发该事件，这时就称为这组进程发生死锁。         所有的死锁都涉及至少两个进程之间对资源的需求冲突。 可重用资源与可消耗资源         可重用资源：一次只供一个进程安全的使用，并且不会因为使用
linux：死锁
dangzhangjing97的博客
04-15 871
在实现线程互斥中，我们是使用了互斥锁，那如果不合理的使用互斥锁，会带来什么危害呢？比如加锁之后却忘记解锁，会导致以下结果： 1.内存泄露 2.死锁 线程互斥请看上一篇博客：https://blog.csdn.net/dangzhangjing97/article/details/79947187 1.死锁是什么 比如你在锁门时，把门锁了，然后出去了，把钥匙丢了，回来...
操作系统实验报告 死锁的避免.pdf
03-30
操作系统实验报告 死锁的避免.pdf操作系统实验报告 死锁的避免.pdf操作系统实验报告 死锁的避免.pdf操作系统实验报告 死锁的避免.pdf操作系统实验报告 死锁的避免.pdf
OS实验：进程管理与死锁
WWWzq_的博客
05-06 743
一. 实验目的 理解进程/线程的概念和应用编程过程 理解进程/线程的同步机制和应用编程 二. 实验内容 三. 实验过程 3.1 在Linux 下创建一对父子进程 分别输出各自的进程号，父进程号和特别的提示字符串信息 让父进程提前结束或后结束，观察子进程的父进程ID 使用PS命令查看进程列表信息，核对进程号，父进程号 创建一个c文件 使用命令vim fork.c，输入以下代码 #include <stdio.h> #include <unistd.h> #include &lt
死锁（Dead Lock）详解
最新发布
m0_54187478的博客
10-17 2315
死锁是多线程或多进程并发编程中的一种常见问题，它发生在两个或多个线程（或进程）相互等待对方释放资源的情况下，导致它们都无法继续执行下去的状态。这种情况下，每个线程都在等待某个资源，而同时也拥有一些资源，这使得它们之间产生了僵局，无法继续执行。死锁通常包括以下四个必要条件：互斥条件（Mutual Exclusion）：每个资源只能同时被一个线程占用。如果一个线程占用了某个资源，其他线程就无法同时占用它。请求与保持条件（Hold and Wait）：线程在持有某些资源的同时，又请求其他资源。
操作系统原理考研 | 死锁、互斥与饥饿问题——“进程会/不会死锁”、“能/不能保证进程互斥进入临界区”、“会/不会出现‘饥饿’现象”一类问题
哆啦一泓的博客
12-27 1167
出题方向：“进程会/不会死锁”、“能/不能保证进程互斥进入临界区”、“会/不会出现‘饥饿’现象”，本人整理了遇到的共6个相关问题，并附上答案：
linux 进程 死锁,Linux：死锁问题
weixin_39924584的博客
04-28 157
之前的博客都多次提到了死锁问题，那么我们先来了解一下。什么是死锁？其实死锁是指在多道程序系统中，一组进程中的每一个进程均无期限的等待被该组进程中的另一个进程所占有且永远不会释放的资源，线程一样。这种现象称系统处于死锁状态，简称死锁。处于死锁状态的进程称为死锁进程。产生死锁的四个必要条件：其实死锁产生：1.资源竞争，2.多道程序运行时的进程推进顺序不合理。也就是4个必要条件：(1)互斥使用资源。资源...
实验四linux操作系统实验报告(1),操作系统实验报告
weixin_39700625的博客
05-12 4049
一. 实验目的及实验环境(一) 实验环境Linux 操作系统(二)实验目的实验1 掌握Linux基本命令 和开发环境掌握常用的Linux shell命令；掌握编辑环境VIM；掌握编译环境gcc及跟踪调试工具gdb。实验2 进程通过观察、分析实验现象，深入理解进程及进程在调度执行和内存空间等方面的特点，掌握在POSIX 规范中fork和kill系统调用的功能和使用。实验3 线程通过观察、分析实验现象...
Linux——死锁
985136449的博客
04-13 355
什么是死锁 例如：现有资源A、B，进程C、D 描述如下： 　　资源A和资源B，都是不可剥夺资源， 　　现在进程C已经申请了资源A，进程D申请了资源B， 　　进程C接下来的操作需要用到资源B，而进程D恰好也在申请资源A， 　　进程C、D都得不到接下来的资源，那么就引发了死锁。 即如果一个进程集合里面（进程C和进 程D）的每个进程（进程C和进程D）都在等待只能由这个集合中的其他一个进程（对
Linux下的死锁
zhu_931的博客
06-10 410
本文参考《操作系统精髓设计原理》第六章（178~191） 一. 死锁的概念   我们可以把死锁定义为一组相互晶振系统资源或通信的进程间的“永久”阻塞。死锁都会涉及两个或者两个以上进程间对资源的冲突。   一般情况下,如果同一个线程先后两次调用lock,在第二次调用时,由于锁已经被占用,该线程会挂起等待别的线程释放锁,然而锁正是被自己占有的,该线程又被挂起没有机会释放锁,因此就永远处于挂起等待状
[Linux]死锁
xxpresent的博客
06-10 538
死锁，产生的原因，死锁的必要条件，预防死锁，避免死锁
linux死锁现象及分析方法
04-11
Linux死锁现象是指发生多个进程或线程同时互相等待对方释放资源的情况，导致所有进程或线程都无法继续执行下去的情况。分析方法一般有两种： 1. 静态分析：通过检查代码、调用图、数据流等信息来分析潜在的死锁点； ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

日星月云

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值