【操作系统】C++ 银行家算法与时间片轮转调度算法结合

逃离我推掉我的手 2024-03-30 09:36 68阅读 0赞

声明：未经允许，请勿转载

一.实验目的

(1) 掌握 RR(时间片调度) 算法，了解 RR 进程调度

(2) 了解死锁概念，理解安全状态，并且理解银行家算法

(3) 利用 RR 进程调度与银行家算法结合，写出一个简单的项目

二.实验原理

2.1 时间片调度算法

在分时系统中都采用时间片轮转算法进行进程调度。时间片是指一个较小的时间间隔，通常为 10- 100 毫秒。在简单的轮转算法中，系统将所有的就绪进程按先来先服务（即 FIFO）规则排成一个队列， 将 CPU 分配给队首进程，且规定每个进程最多允许运行一个时间片；若时间片使用完进程还没有结束， 则被加入就绪 FIFO 队列队尾，并把 CPU 交给下一个进程。时间片轮转算法只用于进程调度，它属于 抢占调度方式。

![d6ec202404104ecfa6debee90127bdfb.png][]

算法实现：

(1) 假设系统中有 5 个进程，每个进程有一个进程控制块（PCB）来标识。进程控制块内容包括：进 程名，链接指针，到达时间，估计运行时间，进程状态。进程名即进程标识。链接指针：按照进 程到达系统的时间将处于就绪状态的进程连接成一个就绪队列。指针指出下一个到达进程的进程 控制块地址。最后一个进程的链接指针为 NULL。

(2) 为每个进程任意确定一个到达时间和要求运行时间。

(3) 设置一个队首指针，用来指出最先进入系统的进程。各就绪进程通过链接指针连在一起构成一个 循环队列。

(4) 处理机调度时开始选择队首指针指向的进程投入运行。由于本实验是模拟试验，所以对被选中进 程并不实际启动运行，而只是执行：估计运行时间减 1。用这个操作来模拟进程的一次运行，而 且省去进程的现场保护和现场恢复工作。 2 电气与计算机工程学院实验报告

(5) 进程运行一次后，以后的调度则将当前指针依次下移一个位置，指向下一个进程。同时还应判断 该进程的剩余的运行时间是否为 0，若不为 0，则等待下一轮的运行；若该进程的剩余时间为 0， 则把它的状态改为完成态（C)，并撤出就绪队列。

(6) 若就绪队列非空，则重复上述的（4）和（5），直到所有进程为完成态。

(7) 在所设计的程序中应有显示或打印语句，能显示或打印正运行进程的进程名、已运行时间、还剩 时间、就绪队列中的进程等。

![cd6c211356254b0295ba6d7002a1209d.png][]

2.2 银行家算法

银行家算法是一种最有代表性的避免死锁的算法。在避免死锁方法中允许进程动态地申请资源， 但系统在进行资源分配之前，应先计算此次分配资源的安全性，若分配不会导致系统进入不安全状态， 则分配，否则等待。为实现银行家算法，系统必须设置若干数据结构。

银行家算法中的数据结构

为了实现银行家算法，在系统中必须设置这样四个数据结构: 可利用资源向量 Available, 最大需 求矩阵 Max, 分配矩阵 Allocation, 需求矩阵 Need.

银行家算法详述：

设 Request；是进程 Pi 的请求向量，如果 Requesti\[j\] = K，表示进程 Pi 需要 K 个 Rj 类型的资 源。当 Pi 发出资源请求后，系统按下述步骤进行检査:

(1) 如果 Requesti\[j\] Need\[i,j\] 便转向步骤

(2)；否则认为出错，因为它所需要的资源数已超过它所 宣布的最大值 (2) 如果 Requesti\[j\] Available\[j\]，便转向步骤

(3)；否则，表示尚无足够资源，Pi 须等待。 (3) 系统试探着把资源分配给进程 Pi，并修改下面数据结构中的数值

Available\[j\] = Available\[j\] − Requesti\[j\]

Allocation\[i, j\] = Allocation\[i, j\] + Requesti\[j\]

Need\[i, j\] = Need\[i, j\] − Requesti\[j\]

(4) 系统执行安全性算法，检查此次资源分配后系统是否处于安全状态。若安全，才正式将资源分 配给进程 Pi，以完成本次分配；否则，将本次的试探分配作废，恢复原来的资源分配状态，让进程 Pi 等待。

安全性算法:

(1) 设置两个向量:工作向量 Work，它表示系统可提供给进程继续运行所需的各类资源数目，它含 有 m 个元素，在执行安全算法开始时，Work = Available； Finish: 它表示系统是否有足够的资源分配 给进程，使之运行完成。开始时先做 Finish\[i\] = false；当有足够资源分配给进程时，再令 Finish\[i\] = true。

(2) 从进程集合中找到一个能满足下述条件的进程 Finish\[i\] = false; Need\[i,j\] Work\[j\]; 若找到，执 行步骤 (3)，否则，执行步骤 (4)。

(3) 当进程 Pi 获得资源后，可顺利执行，直至完成，并释放出分配给它的资源，故应执行:

W ork\[j\] = W ork\[j\] + Allocation\[i, j\]

F inish\[i\] = true

go to step 2

(4) 如果所有进程的 Finish\[i\] =true 都满足，则表示系统处于安全状态；否则，系统处于不安全状态。

![c28a8a0dc9924f1197e4d99da73d1768.png][]

三.实验过程

3.1 RR 算法与银行家算法结合的实现

1、假定系统有 3 类资源 A（10 个）、B（15 个）、C（12 个），系有 5 个进程并发执行，进程调度 采用时间片轮转调度算法。

2、每个进程由一个进程控制块（PCB）表示，进程控制块可以包含如下信息：进程名、需要的资 源总数、已分配的资源数、进程状态。

3、由程序自动生成进程（包括需要的数据，要注意数据的合理范围）。

4、进程在运行过程中会随机申请资源（随机生成请求的资源数），如果达到最大需求，表示该进程 可以完成；如果没有达到最大需求，则运行一个时间片后，调度其它进程运行。资源分配采用银行家算 法来避免死锁。

5、每个进程的状态可以是就绪 W（Wait）、运行 R（Run）、阻塞 B（Block）或完成 F（Finish） 状态之一。 5 电气与计算机工程学院实验报告

6、每进行一次调度，程序都要输出一次运行结果：正在运行的进程、就绪队列中的进程、阻塞队 列中的进程、完成的进程以及各个进程的 PCB，以便进行检查。

![134f86be8ae04d5a8ade07b75b114f34.png][]

完整项目：[C++ 银行家算法与时间片轮转调度算法结合][C_]

#include <stdio.h>
    #include <stdlib.h>
    #include <time.h>
    
    #define TIME_SLICE 2
    
    // 进程状态：就绪 等待 阻塞 完成
    enum process_type{
        process_type_wait = 'W',
        process_type_run = 'R',
        process_type_block = 'B',
        process_type_finish = 'F'
    };
    
    typedef struct PCB{ 
    	// 进程名 
    	char name;
    	// 最大需求资源数
    	int Max[100]; 
    	// 还需要的资源数
    	int Need[100];
    	// 已分配的资源数 
    	int Allocate[100]; 
    	// 进程已运行时间 
    	int run_time; 
    	// 进程状态
    	char state;
    	// 指向下一个进程
    	PCB *next; 
    }PCB; 
    
    // 系统资源的名称
    char Name[100]={0};
    // 系统可用资源向量 
    int Available[100];
    // 进程请求资源向量	
    int Request[100];
    // 存放系统可提供资源量
    int Work[100];  
    // 标记系统是否有足够的资源分配给各个进程
    bool Finish[100];
    // 存放安全序列
    char Security[100];
    
    // 进程的最大数
    int M = 100;
    // 资源的最大数
    int N = 100;
    // 标志是否输出
    bool flag = true; 
    
    // 函数声明
    // 初始化数据
    void init(PCB *list);
    // 创建进程 
    void create_process(PCB *list);
    // 显示资源分配和进程运行情况 
    void print(PCB *list);
    // 试探性分配资源
    void test(PCB *list);
    // 试探性分配资源作废
    void Retest(PCB *list);
    // 利用银行家算法对申请资源进行试分
    bool bank(PCB *list);
    // 安全性算法
    bool safe(PCB *list);
    // 时间片轮转调度算法 
    void round_robin(PCB *list);
    
    // 主函数
    int main(){	
    	printf("-----------------------------------------------------------------------\n");
    	printf("                        银行家算法的实现                               \n");
    	printf("-----------------------------------------------------------------------\n\n");
    	PCB *list = (PCB *)malloc(sizeof(PCB));
    	if(list == NULL){
    		printf("动态分配内存失败！");
    	}
        list->next = NULL;
    	
    	srand((int)time(NULL));
    	// 初始化数据
    	init(list);
    	// 显示资源分配和进程运行情况 
    	printf("***********************************************************************\n");
    	print(list);
        // 用银行家算法判定系统当前时刻是否安全，不安全就不再继续分配资源 
    	if(!safe(list)) {
    		exit(0);
    	}
    	printf("\n***********************************************************************\n");
    	// 使用时间片轮转法进行进程调度 
    	round_robin(list);
        system("pause");
    }
    
    // 初始化数据
    void init(PCB *list){
    	// m为进程数，n为系统资源种类
        int m,n;
    	// 初始化系统资源种类数及各资源数 
    	printf("系统可用资源种类数为：");
    	scanf("%d",&n);
        getchar();
    	// 系统资源种类数，赋给全局变量N，方便后续方法使用 
    	N = n;
    	// 资源名称
    	char name;
    	// 资源数 
    	int number; 
    	for(int i = 1;i <= n;i++){
    		printf("\t资源%d的名称：",i);
    		getchar();
    		scanf("%c",&name);
            getchar();
    		Name[i] = name;
    		printf("\t资源%c的初始个数为：",name);	
    		scanf("%d",&number);
            getchar();
    		Available[i] = number;
    	}
    	// 初始化进程数及各进程的最大需求资源数 
    	printf("\n请输入进程的数量：");	
    	scanf("%d",&m);
    	// 进程数，赋给全局变量M，方便后续方法使用 
    	M = m;
    	create_process(list);
    }
    
    // 创建进程 
    void create_process(PCB *list){
    	// 统计已分配的系统资源
    	int temp[100] = {0};
    	int number = 1; 
    	while(number <= M){
    		// 进程节点 
    		PCB *p = (PCB *)malloc(sizeof(PCB));
    		if(p == NULL){
    			printf("动态分配内存失败！");
    		}
    		// 进程名 
    		printf("\t请输入第%d进程的进程名：",number); 
    		getchar();
    		scanf("%c",&p->name);
    		// 标志变量 
    		bool flag;
    		// 初始化各进程最大需求资源数、仍需资源数和已分配资源数
    		do{
    			flag = false; 
    			for(int i = 1;i <= N;i++){ 
    				p->Max[i] = rand()%10;
    				if(p->Max[i] > Available[i]){ 
    					flag = true;
    					// printf("资源最大需求量大于系统中资源最大数，请重新输入!\n");
    					break;	
    				}
    				p->Need[i] = p->Max[i];
    				p->Allocate[i] = 0;		
    			} 				
    		}while(flag);
    		// 进程已运行时间 
    		p->run_time = 0; 
    		// 进程状态
    		p->state = process_type_wait;
    		// 指向下一个进程
    		p->next = NULL;
    		if(list->next == NULL){
    			list->next = p;
    		}else{
    			PCB *move = list->next;
    			while(move->next != NULL){
    				move = move->next;
    			}
    			move->next = p;	 	
    		}
    		number++;
    	}
    	printf("\n");
    } 
    
    // 显示资源分配和进程运行情况 
    void print(PCB *list){
    	printf("\n系统目前可用的资源(Available):\n");
    	for(int i = 1;i <= N;i++){
    		printf("%c  ",Name[i]);
    	}
    	printf("\n");
    	for(int i = 1;i <= N;i++){
    		printf("%d  ",Available[i]);
    	}
    	printf("\n\n");
    	printf("系统当前的资源分配情况及进程运行情况如下：\n");
    	printf("          Max        Allocate        Need\n");
    	printf("进程名  ");
    	//输出与进程名同行的资源名，Max、Allocate、Need下分别对应 
    	for(int i = 1;i <= 3;i++){
    		for(int j = 1;j <= N;j++){
    			printf("%c  ",Name[j]);
    		}
    		printf("     "); 
    	}
    	printf("已运行时间   进程状态\n");
    	
    	// 遍历链表 
    	PCB *p = list->next;
    	while(p != NULL){
    		//输出每个进程的Max、Allocation、Need 
    		printf("  %c\t",p->name);
    	    for(int j = 1;j <= N;j++)
    			printf("%d  ",p->Max[j]);
    		printf("     "); 
    		for(int j = 1;j <= N;j++)
    			printf("%d  ",p->Allocate[j]);
    		printf("     ");
    		for(int j = 1;j <= N;j++)
    			printf("%d  ",p->Need[j]);
    		printf("        ");
    		printf("  %d\t  ",p->run_time); 
    		printf("%c\n",p->state); 
    		p = p->next;
    	}
    }
    
    // 试探性分配资源
    void test(PCB *list){ 
    	// 请求资源的进程 
    	PCB *p = list->next;
    	// 更改进程信息 
    	for(int i = 1;i <= N;i++){
    		Available[i] -= Request[i];
    		p->Allocate[i] += Request[i];
    		p->Need[i] -= Request[i];
    	}
    }
     
    // 试探性分配资源作废
    void Retest(PCB *list){
     	// 请求资源的进程 
    	PCB *p = list->next;
    	// 与test操作相反 
    	for(int i = 1;i <= N;i++){
    		Available[i] += Request[i];
    		p->Allocate[i] -= Request[i];
    		p->Need[i] += Request[i];
    	}
    }
    
    // 利用银行家算法对申请资源进行试分
    bool bank(PCB *list){
        PCB *p = list->next;
        // 随机生成请求向量
    	for(int i = 1;i <= N;++i){
    		Request[i] = rand()%(p->Need[i]+1);
    	}
    	// 随机产生的请求资源数均为0，表示不理会 
    	int n = 0;
    	for(int i = 1;i <= N;++i){
    		if(Request[i] == 0){
    			n++;
    		}
    	}
    	if(n == N){
    		flag = false;
    		return false;
    	}
    	printf("\n%c进程请求 —— ",p->name);
    	for(int i = 1;i <= N;i++){
    		printf("资源%c：",Name[i]);
    		printf("%d   ",Request[i]); 
    	}
    	printf("\n\n"); 
    	// 定位要求的资源数组下标 
    	int num = 1;
    	// 判断银行家算法的前两条件是否成立 
        for(int i = 1;i <= N;++i){
        	// 判断申请是否大于需求，若大于则出错
    		if(Request[i] > p->Need[i]){ 
    			printf("%c进程申请的资源大于它需要的资源\n",p->name);
    			printf("分配不合理，不予分配！\n");
    			return false;
    		}else{
    			// 判断申请是否大于当前可分配资源，若大于则出错
                if(Request[i] > Available[i]){                         
    				printf("%c进程申请的资源大于系统现可利用的资源\n",p->name);
    				printf("系统尚无足够资源，不予分配!\n");
    				return false;
    			}
    		}
    	}
        // 前两个条件成立，试分配资源，寻找安全序列 
    	// 根据进程需求量,试分配资源
    	test(list); 
    	// 判断系统是否安全 
    	if(!safe(list)){
    		Retest(list);
    		return false;
    	}
    	return true;
    }
    
    // 安全性算法
    bool safe(PCB *list){
    	// 统计未完成进程数 
    	int m = 0;
    	PCB *move = list->next;
    	while(move != NULL && move->state != process_type_finish){
    		move = move->next;
    		++m;
    	}
    	// 初始化Work数组 
    	for(int i = 1;i <= N;i++){
    		Work[i] = Available[i];
    	}
        // 初始化Finish数组 
        for(int i = 1;i <= M;i++){
        	if(i <= m){
        		Finish[i] = false;
    		}else{
    			Finish[i] = true;
    		}
    	} 
    	// 节点位置，判断进程运行 
    	int pnum = 1,apply;
    	int num = 1;
    	// 求安全序列 
    	PCB *p = list->next; 
    	while(p != NULL && pnum <= m){
    		apply = 0;
    		for(int i = 1;i <= N;i++){
    			// 当前进程未完成并且各类资源小于或等于系统资源数 
    			if(Finish[pnum] == false && p->Need[i] <= Work[i]){   
    				apply++;
    				// 直到每类资源尚需数都小于系统可利用资源数才可分配
    				if(apply == N){  
    					for(int x = 1;x <= N;x++){
    						// 更新当前系统可分配资源
    				        Work[x] += p->Allocate[x];
    					} 
    					// 更新标记数组 
    					Finish[pnum] = true;
    					// 更新安全序列数组 
    					Security[num++] = p->name;
    					// 保证每次查询均从第一个进程开始	
    					pnum = 0; 
    					p = list; 
    				}
    			}
    		}
    		// 查询下一进程 
    		pnum++; 
    		p = p->next;
    	}
    	for(int i = 1;i <= M;i++){
    		if(Finish[i] == false){
    			// 系统处于不安全状态 
    			printf("系统不安全！\n");
    			return false;
    		}
    	}
    	// 如果安全，输出安全序列 
        printf("系统是安全的！\n");
        printf("存在一个安全序列:");
    	for(int i = 1;i <= m;i++){
    		// 输出进程运行顺序数组
    		printf(" %c ",Security[i]);
    		if(i < m){
    			printf("->");
    		} 
    	}
    	printf("\n");
    	return true;
    }
    
    // 时间片轮转调度算法 
    void round_robin(PCB *list){
        // 记录第一个结点的位置
        PCB *index = list->next;
        while (index != NULL && index->state != process_type_finish) {
        	// 判断调度后是否输出 
        	flag = true; 
    		// 系统安全，进程分配到资源并运行 
    		if(bank(list)){
    			// 更新已运行时间
    			index->run_time += TIME_SLICE;
    	        // 判断该进程是否完成 
    	        int num = 0;
    	        for(int i = 1;i <= N;++i){
    	        	if(index->Max[i] == index->Allocate[i]){
            			num++;
    				}	
    			}
            	// 该进程已完成 
    	        if (num == N) {
    	            // 修改进程状态
    	            index->state = process_type_finish;
    	            // 回收分配的资源
    	            for(int i = 1;i <= N;i++){
    					Available[i] += index->Allocate[i];
    				}
    	            printf("%c进程完成\n",index->name);
    	        }else{
    	        	// 进程未完成，进入等待 
    	            index->state = process_type_wait;
    	        }
    	        // 当前进程已完成 
    	    	if (index->state == process_type_finish){
    	    		// 将已完成进程调整到已完成队列末尾 
    				// 1.头指针指向首元结点的下一个结点
    		        list->next = index->next;
    		        // 2.遍历整个链表，将其插入到已完成队列的最尾端
    		        PCB *p = list;
    		        while (p->next != NULL) {
    		            p = p->next;
    		        }
    		        p->next = index;
    				index->next = NULL;
    			} else {
    				// 当前进程未完成 
    				// 1.头指针指向首元结点的下一个结点
    		        list->next = index->next;
    		        // 2.遍历整个链表，将其插入到等待队列的最尾端(其后是已完成队列)
    		        PCB *p = list;
    		        // 2.1寻找插入位置
    		        while (p->next != NULL && p->next->state != process_type_finish) {
    		            p = p->next;
    		        }
    		        // 2.2判断插入位置
    		        if (p->next == NULL) {
    		            // 最后一个
    		            p->next = index;
    		            p->next->next = NULL;
    		        }else{
    		            // 不是最后一个，其后仍有结点
    		            index->next = p->next;
    		            p->next = index;
    		        }
    			}	
    		}else{
    			// 该进程请求资源分配会导致系统不安全或请求资源不合理 
    			// 将该进程阻塞并调整到等待队列和已完成队列中间，且是阻塞队列的最后一个 
    			index->state = process_type_block;
    			// 当前进程未完成并处于阻塞状态 
    			// 1.头指针指向首元结点的下一个结点
    	        list->next = index->next;
    	        // 2.遍历整个链表，将其插入到未完成队列后阻塞队列的最后一个
    	        PCB *p = list;
    	        // 2.1寻找插入位置
    	        while (p->next != NULL && p->next->state != process_type_finish) {
    	            p = p->next;
    	        }
    	        // 2.2判断插入位置
    	        if (p->next == NULL) {
    	            // 最后一个
    	            p->next = index;
    	            p->next->next = NULL;
    	        }else{
    	            // 不是最后一个，其后仍有结点
    	            index->next = p->next;
    	            p->next = index;
    	        }
    		}
    		// 展示当前队列状况
    		if(list->next->state != process_type_finish){
    			list->next->state = process_type_run;        	
    		}
    		if(flag){
    	        print(list);	        
    			printf("\n***********************************************************************\n");	
    		}
    		index = list->next;
        }
    }

3.3 实验结果

![f46789eb139e40e3a4edefdaae2715a5.png][]

![531e8f0e87a447d581a25b899d681116.png][]

![70fae138b2044c4697928218367b9404.png][]

![b07eb7510fe1432d8dc5db564eae1422.png][]

![1042fa032f424c1a8363b7a64b35e5d6.png][]

报告页面截图

![90266d95cd1f4d389796dd9bcc4fbc83.png][]

![5c4127a9029c4c708062a0b0f8efe970.png][]

![bc07a115de494269a527de7f18422e48.png][]

![9923fe2980e646dcb43da6636761042a.png][]

![70819fdb3ca846718a9d050fc77addb5.png][]

![856e6daca663494db10cfbf74975085b.png][]

![89dadf3c1cdb45a59a2bf508f1f20c7e.png][]

注：代码借鉴于[http://t.csdnimg.cn/oiub9][http_t.csdnimg.cn_oiub9]

[d6ec202404104ecfa6debee90127bdfb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/8d68897246aa472a8613e781926819be.png
[cd6c211356254b0295ba6d7002a1209d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/9c792f2c137c4fa3bce8a6afb95aa55a.png
[c28a8a0dc9924f1197e4d99da73d1768.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/06279571de24453e8f07fc180c47e9c3.png
[134f86be8ae04d5a8ade07b75b114f34.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/4f1f2c2d267e48d59a4fbb919f417e7d.png
[C_]: https://download.csdn.net/download/weixin_66397563/87651677?spm=1001.2014.3001.5503
[f46789eb139e40e3a4edefdaae2715a5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/f47f4caee1644ce39559faf7414e978f.png
[531e8f0e87a447d581a25b899d681116.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/221af077c6544c0c840487bddcd63dc5.png
[70fae138b2044c4697928218367b9404.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/bea8cbbf808e4e878d689bab1fa0da95.png
[b07eb7510fe1432d8dc5db564eae1422.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/ed5a1ec016884a53aa822612213e456a.png
[1042fa032f424c1a8363b7a64b35e5d6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/ace70109bda249f49cfa7752436ba21f.png
[90266d95cd1f4d389796dd9bcc4fbc83.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/cda47aefc3af470785194be9daf6c4f9.png
[5c4127a9029c4c708062a0b0f8efe970.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/8f98aedd4db74be3bd241064613f3495.png
[bc07a115de494269a527de7f18422e48.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/48f72a63c3994142952d357b6eea4341.png
[9923fe2980e646dcb43da6636761042a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/be8ee67b8a4b4d9e8de2eb7cced51d17.png
[70819fdb3ca846718a9d050fc77addb5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/e5d955771ead4daca1e7605ca6867b4d.png
[856e6daca663494db10cfbf74975085b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/f5ba47c0fe6c4786aab9291da769d4b8.png
[89dadf3c1cdb45a59a2bf508f1f20c7e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/2e31f25cd3a046b79c1b1655264f4566.png
[http_t.csdnimg.cn_oiub9]: http://t.csdnimg.cn/oiub9