C语言银行家算法

2023-05-16

算法简介
银行家算法（Banker’s Algorithm）是一个避免死锁（Deadlock）的著名算法，是由艾兹格·迪杰斯特拉在1965年为T.H.E系统设计的一种避免死锁产生的算法。它以银行借贷系统的分配策略为基础，判断并保证系统的安全运行。

算法目的
为了了解系统的资源分配情况，假定系统的任何一种资源在任意时刻只能被一个进程使用，任何进程已经占用的资源只能由进程自己释放，而不能由其他进程抢占，当进程申请的资源不能满足时，必须等待。因此只要资源分配算法能保证进程的资源请求，且不出现循环等待，则系统不会出现死锁。

算法原理
在避免死锁的方法中，所施加的限制条件较弱，有可能获得令人满意的系统性能。在该方法中把系统的状态分为安全状态和不安全状态，只要能使系统始终都处于安全状态，便可以避免发生死锁。

银行家算法的基本思想是分配资源之前，判断系统是否是安全的；若是，才分配。它是最具有代表性的避免死锁的算法。

设进程cusneed提出请求REQUEST [i]，则银行家算法按如下规则进行判断。

(1)如果REQUEST [cusneed] [i]<= NEED[cusneed][i]，则转（2)；否则，出错。
(2)如果REQUEST [cusneed] [i]<= AVAILABLE[i]，则转（3)；否则，等待。
(3)系统试探分配资源，修改相关数据：
AVAILABLE[i]-=REQUEST[cusneed][i];

ALLOCATION[cusneed][i]+=REQUEST[cusneed][i];

NEED[cusneed][i]-=REQUEST[cusneed][i];

(4)系统执行安全性检查，如安全，则分配成立；否则试探险性分配作废，系统恢复原状，进程等待。
安全性检查算法

（1）设置两个工作向量Work=AVAILABLE;FINISH
（2）从进程集合中找到一个满足下述条件的进程，
FINISH==false;

NEED<=Work;

如找到，执行（3)；否则，执行（4)

(3)设进程获得资源，可顺利执行，直至完成，从而释放资源。
Work=Work+ALLOCATION;

Finish=true;

GOTO 2
这里写图片描述
原始代码：

#include<stdio.h>
#define true 1
#define false 0
#define processNum 5
#define resourceNum 3
#define MAXINT 9999
typedef int bool;

int available[resourceNum]={3,3,2};
int maxRequest[processNum][resourceNum]={7,5,3,3,2,2,9,0,2,2,2,2,4,3,3};
int allocation[processNum][resourceNum]={0,1,0,2,0,0,3,0,2,2,1,1,0,0,2};
int need[processNum][resourceNum]={7,4,3,1,2,2,6,0,0,0,1,1,4,3,1};
bool Finish[processNum];
int safeSeries[processNum]={MAXINT, MAXINT , MAXINT , MAXINT , MAXINT};
int request[resourceNum];

void Init()
{
    int i, j;
    printf("输入进程数量、资源数量\n");
    //scanf("%d %d",&processNum,&resourceNum);
    printf("输入当前资源可用数目\n");
    for(i = 0; i < resourceNum; i++){
        scanf("%d",&available[i]);
    }
    printf("输入最大需求矩阵\n");
    for(i = 0; i < processNum; i++){
        for(j = 0; j < resourceNum; j++){
            scanf("%d",&maxRequest[i][j]);
        }
    }
    printf("输入分配矩阵\n");
    for(i = 0; i < processNum; i++){
        for(j = 0; j < resourceNum; j++){
            scanf("%d",&allocation[i][j]);
        }
    }
    printf("输入当前需求矩阵\n");
    for(i = 0; i < processNum; i++){
        for(j = 0; j < resourceNum; j++){
            scanf("%d",&need[i][j]);
        }
    }
}

void showInfo()
{
    int i,j;
    printf("当前资源剩余：");
    for(j = 0; j < resourceNum; j++){
        printf("%d ",available[j]);
    }
    printf("\n");
    printf(" PID\t Max\t\tAllocation\tNeed\n");
    for(i = 0; i < processNum; i++){
        printf(" P%d\t",i);
        for(j = 0; j < resourceNum; j++){
            printf("%d ",maxRequest[i][j]);
        }
        printf("\t\t");
        for(j = 0; j < resourceNum; j++){
            printf("%d ",allocation[i][j]);
        }
        printf("\t\t");
        for(j = 0; j < resourceNum; j++){
            printf("%d ",need[i][j]);
        }
        printf("\n");
    }
}

bool isSafe()
{
    int i,j,k;
    int trueFinished = 0;
    int work[resourceNum];
    for(i = 0; i < resourceNum; i++){
        work[i]=available[i];
    }

    for(i = 0; i < processNum; i++){
        Finish[i]=false;
    }
    i = 0;
    int temp = 0;
    while(trueFinished != processNum){
        int j =0;
        if(Finish[i]!= true){
            for(j = 0; j < resourceNum; j++){
                if(need[i][j] > work[j]){break;}
            }
        }
        if(j == resourceNum){
            Finish[i]=true;
            SafeInfo(work,i);
            for(k = 0; k < resourceNum; k++){
                work[k]+=allocation[i][k];
            }
            int k2;
            safeSeries[trueFinished++] = i;
        }
        i++;
        if(i >= processNum)
        {
            i = i % processNum;
            if(temp == trueFinished)
                break;
        }
        temp = trueFinished;
    }

    if(trueFinished == processNum){
        printf("\n系统安全！\n\n安全序列为：");
        for(i = 0; i < processNum; i++){
            printf("%d ",safeSeries[i]);
        }
        return true;
    }
    printf("******系统不安全！******\n");
    return false;
}

void SafeInfo(int *work, int i)
{
    int j;
    printf(" P%d\t",i);
    for(j = 0; j < resourceNum; j++){
        printf("%d ",work[j]);
    }
    printf("\t\t");
    for(j = 0; j < resourceNum; j++){
        printf("%d ",need[i][j]);
    }
    printf("\t ");
    for(j = 0; j < resourceNum; j++){
        printf("%d ",allocation[i][j]);
    }
    printf("\t\t");
    for(j = 0; j < resourceNum; j++){
        printf("%d ",allocation[i][j]+work[j]);
    }
    printf("\n");
}


int main()
{
    int i,j,curProcess;
    int wheInit = 0;
    printf("是否使用内置数据？0是，1否：");
    scanf("%d",&wheInit);
    if(wheInit)
        Init();  //可以不使用，选用内置的数据进行测试
    printf("---------------------------------------------------------\n");
    showInfo();
    printf("\n系统安全情况分析\n");
    printf(" PID\t Work\t\tNeed\tAllocation\tWork+Allocation\n");
    isSafe();
    while(true){
        printf("\n---------------------------------------------------------\n");
        printf("\n输入要分配的进程：");
        scanf("%d",&curProcess);
        printf("\n输入要分配给进程P%d的资源：",curProcess);
        for(j = 0; j < resourceNum; j++){
            scanf("%d", &request[j]);
        }
        for(j = 0; j < resourceNum; j++){
            if(request[j] <= need[curProcess][j])continue;
            else{printf("ERROR！\n");break;}
        }
        if(j == resourceNum){
            for(j = 0; j < resourceNum; j++){
                if(request[j] <= need[curProcess][j])continue;
                else{printf("资源不足，等待中！\n");break;}
            }
            if(j == resourceNum){
                for(j = 0; j < resourceNum; j++){
                    available[j] -= request[j];
                    allocation[curProcess][j] += request[j];
                    need[curProcess][j] -= request[j];
                }
                printf("\n系统安全情况分析\n");
                printf(" PID\t Work\t\tNeed\tAllocation\tWork+Allocation\n");
                if(isSafe()){
                    printf("分配成功！\n");
                    showInfo();
                }else{
                    for(j = 0; j < resourceNum; j++){
                        available[j] += request[j];
                        allocation[curProcess][j] -= request[j];
                        need[curProcess][j] += request[j];
                    }
                    printf("分配失败！\n");
                    showInfo();
                }
            }
        }
    }
}

这里写图片描述
修正后的代码：参考评论Sean0977

#include<stdio.h>
#define true 1
#define false 0
#define processNum 5
#define resourceNum 3
#define MAXINT 9999
typedef int bool;

int available[resourceNum]={3,3,2};
int maxRequest[processNum][resourceNum]={7,5,3,3,2,2,9,0,2,2,2,2,4,3,3};
int allocation[processNum][resourceNum]={0,1,0,2,0,0,3,0,2,2,1,1,0,0,2};
int need[processNum][resourceNum]={7,4,3,1,2,2,6,0,0,0,1,1,4,3,1};
bool Finish[processNum];
int safeSeries[processNum]={MAXINT, MAXINT , MAXINT , MAXINT , MAXINT};
int request[resourceNum];

void Init()
{
    int i, j;
    printf("输入进程数量、资源数量\n");
    //scanf("%d %d",&processNum,&resourceNum);
    printf("输入当前资源可用数目\n");
    for(i = 0; i < resourceNum; i++){
        scanf("%d",&available[i]);
    }
    printf("输入最大需求矩阵\n");
    for(i = 0; i < processNum; i++){
        for(j = 0; j < resourceNum; j++){
            scanf("%d",&maxRequest[i][j]);
        }
    }
    printf("输入分配矩阵\n");
    for(i = 0; i < processNum; i++){
        for(j = 0; j < resourceNum; j++){
            scanf("%d",&allocation[i][j]);
        }
    }
    printf("输入当前需求矩阵\n");
    for(i = 0; i < processNum; i++){
        for(j = 0; j < resourceNum; j++){
            scanf("%d",&need[i][j]);
        }
    }
}

void showInfo()
{
    int i,j;
    printf("当前资源剩余：");
    for(j = 0; j < resourceNum; j++){
        printf("%d ",available[j]);
    }
    printf("\n");
    printf(" PID\t Max\t\tAllocation\tNeed\n");
    for(i = 0; i < processNum; i++){
        printf(" P%d\t",i);
        for(j = 0; j < resourceNum; j++){
            printf("%d ",maxRequest[i][j]);
        }
        printf("\t\t");
        for(j = 0; j < resourceNum; j++){
            printf("%d ",allocation[i][j]);
        }
        printf("\t\t");
        for(j = 0; j < resourceNum; j++){
            printf("%d ",need[i][j]);
        }
        printf("\n");
    }
}

bool isSafe()
{
    int i,j,k;
    int trueFinished = 0;
    int work[resourceNum];
    for(i = 0; i < resourceNum; i++){
        work[i]=available[i];
    }

    for(i = 0; i < processNum; i++){
        Finish[i]=false;
    }
    i = 0;
    int temp = 0;
    while(trueFinished != processNum){
        int j =0;
        if(Finish[i]!= true){
            for(j = 0; j < resourceNum; j++){
                if(need[i][j] > work[j]){break;}
            }
        }
        if(j == resourceNum){
            Finish[i]=true;
            SafeInfo(work,i);
            for(k = 0; k < resourceNum; k++){
                work[k]+=allocation[i][k];
            }
            int k2;
            safeSeries[trueFinished++] = i;
        }
        i++;
        if(i >= processNum)
        {
        	if(flag==0)
        	{
        		temp=trueFinished;
        		temp0=trueFinished;        		
			}
            i = i % processNum;         
            if(flag==1){
            temp=trueFinished;
            if(temp == temp0)
                break;
            else
            	temp0=temp;
            }        
            flag=1;
        }
        temp = trueFinished;
    }

    if(trueFinished == processNum){
        printf("\n系统安全！\n\n安全序列为：");
        for(i = 0; i < processNum; i++){
            printf("%d ",safeSeries[i]);
        }
        return true;
    }
    printf("******系统不安全！******\n");
    return false;
}

void SafeInfo(int *work, int i)
{
    int j;
    printf(" P%d\t",i);
    for(j = 0; j < resourceNum; j++){
        printf("%d ",work[j]);
    }
    printf("\t\t");
    for(j = 0; j < resourceNum; j++){
        printf("%d ",need[i][j]);
    }
    printf("\t ");
    for(j = 0; j < resourceNum; j++){
        printf("%d ",allocation[i][j]);
    }
    printf("\t\t");
    for(j = 0; j < resourceNum; j++){
        printf("%d ",allocation[i][j]+work[j]);
    }
    printf("\n");
}


int main()
{
    int i,j,curProcess;
    int wheInit = 0;
    printf("是否使用内置数据？0是，1否：");
    scanf("%d",&wheInit);
    if(wheInit)
        Init();  //可以不使用，选用内置的数据进行测试
    printf("---------------------------------------------------------\n");
    showInfo();
    printf("\n系统安全情况分析\n");
    printf(" PID\t Work\t\tNeed\tAllocation\tWork+Allocation\n");
    isSafe();
    while(true){
        printf("\n---------------------------------------------------------\n");
        printf("\n输入要分配的进程：");
        scanf("%d",&curProcess);
        printf("\n输入要分配给进程P%d的资源：",curProcess);
        for(j = 0; j < resourceNum; j++){
            scanf("%d", &request[j]);
        }
        for(j = 0; j < resourceNum; j++){
            if(request[j] <= need[curProcess][j])continue;
            else{printf("ERROR！\n");break;}
        }
        if(j == resourceNum){
            for(j = 0; j < resourceNum; j++){
                if(request[j] <= need[curProcess][j])continue;
                else{printf("资源不足，等待中！\n");break;}
            }
            if(j == resourceNum){
                for(j = 0; j < resourceNum; j++){
                    available[j] -= request[j];
                    allocation[curProcess][j] += request[j];
                    need[curProcess][j] -= request[j];
                }
                printf("\n系统安全情况分析\n");
                printf(" PID\t Work\t\tNeed\tAllocation\tWork+Allocation\n");
                if(isSafe()){
                    printf("分配成功！\n");
                    showInfo();
                }else{
                    for(j = 0; j < resourceNum; j++){
                        available[j] += request[j];
                        allocation[curProcess][j] -= request[j];
                        need[curProcess][j] += request[j];
                    }
                    printf("分配失败！\n");
                    showInfo();
                }
            }
        }
    }
}

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

语言银行家算法

C语言银行家算法的相关文章

k-means算法概述

优点与缺点 K means算法思想 K MEANS算法是输入聚类个数k xff0c 以及包含 n个数据对象的数据库 xff0c 输出满足方差最小标准k个聚类的一种算法 k means 算法接受输入量 k xff1b 然后将n个数据对象划分为
MATLAB随机数生成器

1 rand 生成 0 1 区间上均匀分布的随机数基本语法 xff1a rand M N P 生成排列成M N P 多维向量的随机数如果只写M xff0c 则生成M M矩阵 xff1b 如果参数为 M N 可以省略方括号 2 randn
Python弹球游戏（tkinter模块编写）

python弹球游戏 xff0c 能够选择难度和分数控制程序利用tkinter模块编写 xff08 说到这里吐槽一下tkinter模块 xff0c 虽然tkinter是python自带的模块 xff0c 但是编写手感真没有wxpython
SSH登录时提示Read from socket failed: Connection reset by peer.

首先查看日志 tail f var log auth log 添加参数 v 获得更详细的连接信息 ssh user 64 computerB v 1 如果是 rsa and dsa keys 丢失产生的问题可以通过下面的方式进行修复 ss
Python密码存储器

xff08 不使用数据库 xff09 设计一个密码记录及查询小软件 xff0c 模拟记录自己在各个网站上所使用的账号及密码 xff0c 保存在文件中要求自行设计存储方式 xff0c 并实现浏览 xff0c 查询 xff0c 增加 xff0
Python英文搜索引擎（模糊搜索）

假设在C Record下面有若干个 txt文件 xff0c 均为纯英文文档以这些文档为内容 xff0c 实现一个本地搜索引擎 xff0c 当用户给出某个输入时 xff0c 列出相关的搜索结果可以自行决定改搜索引擎的功能强弱 xff0c
wxpython记录生词GUI程序

不使用数据库实现一个简单的记生词软件 xff0c 基本功能包括 xff0c 添加新的生词及其中文含义 xff0c 浏览已经记录的单词 xff0c 随机选择部分单词进行复习可考虑其它拓展的功能这里使用wxpython的基本操作 xff0
数据结构电视大赛投票系统

电视大赛观众投票及排名系统的设计与实现 8学时问题描述 xff1a 在很多的电视大赛中 xff0c 通常当选手表演结束后 xff0c 现场观众通过手中的按键对参赛选手进行投票 xff0c 然后对选手获得的票数进行统计 xff0c 从高到低
监督学习与无监督学习

机器学习如果按照训练样本标签的有无可以分为以下两种常用方法有监督学习 supervised learning 和无监督学习 unsupervised learning 以机器学习中的分类 classification 来说 xff0c 输
Python授权码生成器（密码生成器）

有时候我们需要为自己的产品设置一些使用权限 xff0c 这就需要随机授权码生成器当然这是简单的随机生成器 xff0c 像Adobe这种授权码是需要一定的加密算法生成 xff0c 然后再验证授权码是否正确 xff0c 而不是简单的生成本文
C语言赌博机掷骰子

一个C语言写的小游戏赌博机 xff0c 适合学习C语言的人学习借鉴 A C language to write a small game gambling machines suitable for learning C language
Linux基本命令

由于参加了机器人社团 xff0c 涉足了Linux的知识 xff0c 今天开始写第一篇关于Linux的文章 Linux简介 xff08 百度百科 xff09 xff1a https baike baidu com item linux 27
如何正确给锂电池充电

刚给手机换了新电池 xff0c 发现很多人在手机和电脑充电方面存在着误区 xff0c 比如下面这个流言流言 xff1a 新买的手机必须充满8小时以上并重复几次完全充电放电 xff0c 这个过程叫做激活 xff0c 这样可以使手机的电池达到
Python代码刷博客访问量

寒假闲着无聊自习研究了一下Python爬虫与代理就发现了一个很简单的刷博客访问量的技巧首先 xff0c 我们设置一个代理池 xff0c 可以用数据库导入也可以简单的用一个数组代理池可以从http www xicidaili com 选
eclipse svn 分支合并到主干

首先需厘清SVN的分支以下几个概念 xff1a trunk 主干可以理解为开发环境的代码 xff0c 平常做开发的工作目录 branches xff1a 从主干拷贝了一份代码重新在svn服务器上的建了个分支目录通常叫branch xff
Python GUI程序整理

文章目录 GUI程序 Python课程设计Windows系统资源探测器 Python密码存储器 wxpython简单记录生词GUI程序 python微博爬虫GUI程序 Python刷访问量GUI程序 Python弹球游戏 xff08 tki
基于词典的社交媒体内容的情感分析（Python实现）

之前写了一篇基于NLTK情感预测的文章http www omegaxyz com 2017 12 15 nltk emotion hilite 61 27NLTK 27b 更多内容访问omegaxyz com 情感词典是从微博新闻论坛等
在Linux（Ubuntu）下编写编译C语言

大家都知道在Windows中运行C语言很简单 xff0c 打开一个IDE xff08 VS或者codeblocks xff09 编写代码 xff0c 点击一个按钮就能运行了在Linux中 xff0c 大家不怎么习惯用IDE xff0c 更
提高C++运行效率的方法

一尽量减少值传递 xff0c 多用引用来传递参数至于其中的原因 xff0c 相信大家也很清楚 xff0c 如果参数是int等语言自定义的类型可能能性能的影响还不是很大 xff0c 但是如果参数是一个类的对象 xff0c 那么其效率问题就

随机推荐

第十三次CCF CSP认证（2018年3月）真题跳一跳

跳一跳问题描述近来 xff0c 跳一跳这款小游戏风靡全国 xff0c 受到不少玩家的喜爱简化后的跳一跳规则如下 xff1a 玩家每次从当前方块跳到下一个方块 xff0c 如果没有跳到下一个方块上则游戏结束如果跳到了方块上 xff0c
第十三次CCFCSP认证（2018年3月）真题碰撞的小球

问题描述数轴上有一条长度为L xff08 L为偶数的线段 xff0c 左端点在原点 xff0c 右端点在坐标L处有n个不计体积的小球在线段上 xff0c 开始时所有的小球都处在偶数坐标上 xff0c 速度方向向右 xff0c 速度大小
第十三次CCF CSP认证（2018年3月）真题URL映射

问题描述 URL 映射是诸如 Django Ruby on Rails 等网页框架 web frameworks 的一个重要组件对于从浏览器发来的 HTTP 请求 xff0c URL 映射模块会解析请求中的 URL 地址 xff0c 并将
第十三次CCF CSP认证（2018年3月）真题棋局评估

问题描述 Alice和Bob正在玩井字棋游戏井字棋游戏的规则很简单 xff1a 两人轮流往3 3的棋盘中放棋子 xff0c Alice放的是 X xff0c Bob放的是 O xff0c Alice执先当同一种棋子占据一行一列或一条对
第十三次CCF CSP认证（2018年3月）真题二次求和

问题描述给一棵 n 个节点的树 xff0c 用 1 到 n 的整数表示每个节点上有一个整数权值 ai 再给出两个整数 L R 现在有 m 个操作 xff0c 每个操作这样描述 xff1a 给定树上两个节点 u v 和一个整数 d xff
演化计算基本方法与思想

生物系统中 xff0c 进化被认为是一种成功的自适应方法 xff0c 具有很好的健壮性基本思想 xff1a 达尔文进化论是一种稳健的搜索和优化机制大多数生物体是通过自然选择和有性生殖进行进化自然选择决定了群体中哪些个体能够生存和繁殖
发布jar包到Maven中央仓库

平时自己开发的工具类或者其他的框架的jar包一般都是放在本地或者把代码上传到github让别人去下载然后自己打包今天就说说如何把自己的jar包发布到Maven的中央仓库让其他使用你的jar包的直接去中央仓库下载如果你用的是阿里云的m
机器学习术语表

本术语表中列出了一般的机器学习术语和 TensorFlow 专用术语的定义原文地址 xff1a https developers google cn machine learning glossary hl 61 zh CN A A B
Python单下划线与双下划线

foo 一种约定 Python内部的名字用来区别其他用户自定义的命名以防冲突 foo 一种约定用来指定变量私有程序员用来指定私有变量的一种方式 foo 这个有真正的意义解析器用 classname foo来代替这个名字以区别和其
wxpython控件自适应窗口大小

问题 xff1a wxpython作的窗口 xff0c 点击窗口最大化 xff0c 就会出问题 xff0c 1 窗口控件并不一起最大化 2 最大化后有些控件找不着了 xff0c 再恢复窗口 xff0c 那些消失的控件一样找不到 wxPyth
Python统计磁盘代码文件行数

听说简历要求10万行代码经验于是写了个Python脚本用来计算电脑磁盘内代码的行数主要功能 xff1a 统计指定代码的总行数统计每个代码单独的行数自定义设置存储路径设计思路 xff1a 将文件转化为txt文档 xff0c 对txt
第一个Android程序

Android Studio 是一个Android集成开发工具 xff0c 基于IntelliJ IDEA 类似 Eclipse ADT xff0c Android Studio 提供了集成的 Android 开发工具用于开发和调试在ID
面向过程与面向对象代码实例对比

面向过程式代码 xff08 使用数据结构的代码 xff09 便于在不改动既有数据结构的前提下添加新函数面向对象代码便于在不改动既有函数前提下添加新类过程式代码难以添加数据结构 xff0c 因为必须修改所有函数面向对象代码难以添加新函数
机器学习

文章目录机器学习基本理论基本术语与方法特征选择概述多目标优化问题分类算法经典算法分类算法NSGA2算法粒子群优化算法 xff08 PSO xff09 聚类算法蚁群算法 xff08 ACO xff09 其它算法前沿算法 NSGA2
英文字母信息熵与冗余度计算Python实现

26个英文字母在平均出现时的信息熵是4 7BIT 而去掉冗余度后的英文字母的信息熵是4 03BIT 公式 H 信息熵 61 Pi log2 Pi Pi 为每个字母在信息中出现的概率计算公式并不复杂取以2为底的对数的道理也很简单因为如果
C++静态成员详解

静态成员是解决同一个类的不同对象之间数据和函数共享问题的实例属性 xff1a 一个类的所有对象具有相同的属性 xff0c 属性值可以不同类属性 xff1a 描述类的所有对象共同特征 xff0c 对于任何对象其属性值相同静态数据成员用
混淆矩阵简介与Python实现

什么是混淆矩阵混淆矩阵是机器学习中总结分类模型预测结果的情形分析表 xff0c 以矩阵形式将数据集中的记录按照真实的类别与分类模型作出的分类判断两个标准进行汇总这个名字来源于它可以非常容易的表明多个类别是否有混淆 xff08 也就是一个
JAVA CPU占用过高问题排查

1 查找进程 top查看进程占用资源情况明显看出java的两个进程22714 xff0c 12406占用过高cpu 2 查找线程使用top H p lt pid gt 查看线程占用情况 3 查找java的堆栈信息将线程id转换成十六进
【译】Python3.8官方Logging文档（完整版）

注 xff1a 文章很长 xff0c 约一万字左右 xff0c 可以先收藏慢慢看哟 01 基础部分日志是用来的记录程序运行事件的工具当程序员可以通过添加日志打印的代码来记录程序运行过程中发生的某些事件时这些事件包含了诸如变量数据在内的
C语言银行家算法

算法简介银行家算法 xff08 Banker s Algorithm xff09 是一个避免死锁 xff08 Deadlock xff09 的著名算法 xff0c 是由艾兹格迪杰斯特拉在1965年为T H E系统设计的一种避免死锁产生的

C语言银行家算法

C语言银行家算法 的相关文章

随机推荐

热门标签

C语言银行家算法的相关文章