├── src
    └── main
    │   ├── resources
    │       ├── application.properties
    │       └── static
    │       │   └── index.html
    │   └── java
    │       └── com
    │           └── banker
    │               ├── entity
    │                   ├── InitNumber.java
    │                   ├── AddRequestDto.java
    │                   ├── FinalDto.java
    │                   └── RestBean.java
    │               ├── BankerApplication.java
    │               └── controller
    │                   └── BankController.java
├── .gitattributes
├── README.md
└── pom.xml


/src/main/resources/application.properties:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/.gitattributes:
--------------------------------------------------------------------------------
1 | *.js linguist-language=java
2 | *.css linguist-language=java
3 | *.html linguist-language=java
4 | 


--------------------------------------------------------------------------------
/src/main/java/com/banker/entity/InitNumber.java:
--------------------------------------------------------------------------------
 1 | package com.banker.entity;
 2 | 
 3 | import lombok.Data;
 4 | 
 5 | /**
 6 |  * @Author: Silvery
 7 |  * @Date: 2023/7/5 15:57
 8 |  */
 9 | @Data
10 | public class InitNumber {
11 | 
12 |     Integer processesNumber;
13 |     Integer assetsNumber;
14 | }
15 | 


--------------------------------------------------------------------------------
/src/main/java/com/banker/entity/AddRequestDto.java:
--------------------------------------------------------------------------------
 1 | package com.banker.entity;
 2 | 
 3 | import lombok.Data;
 4 | 
 5 | import java.util.List;
 6 | 
 7 | /**
 8 |  * @Author: Silvery
 9 |  * @Date: 2023/7/6 15:42
10 |  */
11 | @Data
12 | public class AddRequestDto {
13 |     Integer processNum;
14 |     List<Integer> requestList;
15 | }
16 | 


--------------------------------------------------------------------------------
/src/main/java/com/banker/entity/FinalDto.java:
--------------------------------------------------------------------------------
 1 | package com.banker.entity;
 2 | 
 3 | import lombok.Data;
 4 | 
 5 | import java.util.List;
 6 | 
 7 | /**
 8 |  * @Author: Silvery
 9 |  * @Date: 2023/7/5 21:08
10 |  */
11 | @Data
12 | public class FinalDto {
13 |     List<Integer> max;
14 |     List<Integer> allocation;
15 |     List<Integer> need;
16 | }
17 | 


--------------------------------------------------------------------------------
/src/main/java/com/banker/entity/RestBean.java:
--------------------------------------------------------------------------------
 1 | package com.banker.entity;
 2 | 
 3 | import lombok.AllArgsConstructor;
 4 | import lombok.Data;
 5 | import lombok.NoArgsConstructor;
 6 | 
 7 | /**
 8 |  * @Author: Silvery
 9 |  * @Date: 2023/7/5 17:03
10 |  */
11 | @Data
12 | @AllArgsConstructor
13 | @NoArgsConstructor
14 | public class RestBean<T> {
15 |     int code;
16 |     T data;
17 | }
18 | 


--------------------------------------------------------------------------------
/src/main/java/com/banker/BankerApplication.java:
--------------------------------------------------------------------------------
 1 | package com.banker;
 2 | 
 3 | import org.springframework.boot.SpringApplication;
 4 | import org.springframework.boot.autoconfigure.SpringBootApplication;
 5 | 
 6 | @SpringBootApplication
 7 | public class BankerApplication {
 8 | 
 9 |     public static void main(String[] args) {
10 |         SpringApplication.run(BankerApplication.class, args);
11 |     }
12 | 
13 | }
14 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Java-Banker
 2 | ## SpringBoot实现银行家算法的一个小Demo
 3 | 由于操作系统大型试验的需要，做了一个操作系统中实现银行家算法的小demo
 4 | 前端使用了纯html加js控制dom生成元素，全部手撕，没有使用任何框架
 5 | 后端使用了java后台，springboot应用程序
 6 | 
 7 | ## 下载使用
 8 | 直接clone下代码，配置好自己的maven，启动BankerApplication即可，需要java8及以上版本
 9 | 
10 | ## BUG
11 | 由于为了完成作业，所以只做到了申请资源，和新建线程的新建部分，新建部分也有一些瑕疵；
12 | 还有释放资源未完成，感兴趣的小伙伴可以尝试一下，本人对此不感兴趣，固大概率不会进行改进升级；
13 | 
14 | ## 最后
15 | 如果你也需要写一个web端的银行家算法，这里的功能拿去，过关应该没有问题，如果想拿高分，则需自行升级改进
16 | 


--------------------------------------------------------------------------------
/pom.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 3 |          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
 4 |     <modelVersion>4.0.0</modelVersion>
 5 |     <parent>
 6 |         <groupId>org.springframework.boot</groupId>
 7 |         <artifactId>spring-boot-starter-parent</artifactId>
 8 |         <version>2.7.13</version>
 9 |         <relativePath/> <!-- lookup parent from repository -->
10 |     </parent>
11 |     <groupId>com.banker</groupId>
12 |     <artifactId>banker</artifactId>
13 |     <version>0.0.1-SNAPSHOT</version>
14 |     <name>banker</name>
15 |     <description>banker</description>
16 |     <properties>
17 |         <java.version>8</java.version>
18 |     </properties>
19 |     <dependencies>
20 |         <dependency>
21 |             <groupId>org.springframework.boot</groupId>
22 |             <artifactId>spring-boot-starter-web</artifactId>
23 |         </dependency>
24 | 
25 |         <dependency>
26 |             <groupId>org.projectlombok</groupId>
27 |             <artifactId>lombok</artifactId>
28 |             <optional>true</optional>
29 |         </dependency>
30 |         <dependency>
31 |             <groupId>org.springframework.boot</groupId>
32 |             <artifactId>spring-boot-starter-test</artifactId>
33 |             <scope>test</scope>
34 |         </dependency>
35 |     </dependencies>
36 | 
37 |     <build>
38 |         <plugins>
39 |             <plugin>
40 |                 <groupId>org.springframework.boot</groupId>
41 |                 <artifactId>spring-boot-maven-plugin</artifactId>
42 |                 <configuration>
43 |                     <excludes>
44 |                         <exclude>
45 |                             <groupId>org.projectlombok</groupId>
46 |                             <artifactId>lombok</artifactId>
47 |                         </exclude>
48 |                     </excludes>
49 |                 </configuration>
50 |             </plugin>
51 |         </plugins>
52 |     </build>
53 | 
54 | </project>
55 | 


--------------------------------------------------------------------------------
/src/main/java/com/banker/controller/BankController.java:
--------------------------------------------------------------------------------
  1 | package com.banker.controller;
  2 | 
  3 | import com.banker.entity.AddRequestDto;
  4 | import com.banker.entity.FinalDto;
  5 | import com.banker.entity.InitNumber;
  6 | import com.banker.entity.RestBean;
  7 | import org.springframework.web.bind.annotation.PostMapping;
  8 | import org.springframework.web.bind.annotation.RequestBody;
  9 | import org.springframework.web.bind.annotation.RequestMapping;
 10 | import org.springframework.web.bind.annotation.RestController;
 11 | 
 12 | import java.util.ArrayList;
 13 | import java.util.Arrays;
 14 | import java.util.List;
 15 | 
 16 | /**
 17 |  * @Author: Silvery
 18 |  * @Date: 2023/7/5 15:55
 19 |  */
 20 | @RestController
 21 | @RequestMapping("/bank")
 22 | public class BankController {
 23 | 
 24 |     private Integer processesNumber; // 进程数
 25 |     private Integer assetsNumber; // 资源数
 26 |     private List<Integer> assetsList; // 每个资源总数
 27 |     private List<Integer> availableList; // 每个资源剩余资源数
 28 |     private List<Integer> request;
 29 |     private int[][] need = new int[100][100];
 30 |     private int[][] max = new int[100][100];
 31 |     private int[][] allocation = new int[100][100];
 32 |     private int processNum;
 33 |     private List<Integer> chokeList = new ArrayList<>();
 34 | 
 35 |     @PostMapping("/initNumber")
 36 |     public RestBean initNumber(@RequestBody InitNumber initNumber) {
 37 |         processesNumber = initNumber.getProcessesNumber();
 38 |         assetsNumber = initNumber.getAssetsNumber();
 39 |         if (processesNumber != null && assetsNumber != null)
 40 |             return new RestBean<>(200, null);
 41 |         return new RestBean<>(400, "请检查参数是否正确");
 42 |     }
 43 | 
 44 |     @PostMapping("/initAssets")
 45 |     public RestBean initAssets(@RequestBody List<Integer> assetesList) {
 46 |         this.availableList = assetesList;
 47 |         return new RestBean<>(200, null);
 48 |     }
 49 | 
 50 |     @PostMapping("/initOtherAndMath")
 51 |     public RestBean initOtherAndMath(@RequestBody FinalDto finalDto) {
 52 |         for (int i = 0; i < (finalDto.getNeed().size() / assetsNumber); i++)
 53 |             for (int j = 0; j < assetsNumber; j++)
 54 |                 need[i][j] = finalDto.getNeed().get(i * assetsNumber + j);
 55 |         for (int i = 0; i < (finalDto.getMax().size() / assetsNumber); i++)
 56 |             for (int j = 0; j < assetsNumber; j++)
 57 |                 max[i][j] = finalDto.getMax().get(i * assetsNumber + j);
 58 |         for (int i = 0; i < (finalDto.getAllocation().size() / assetsNumber); i++)
 59 |             for (int j = 0; j < assetsNumber; j++)
 60 |                 allocation[i][j] = finalDto.getAllocation().get(i * assetsNumber + j);
 61 |         assetsList = new ArrayList<>();
 62 |         for (int i = 0; i < availableList.size(); i ++) {
 63 |             int sum = 0;
 64 |             for (int[] arr : allocation)
 65 |                 sum += arr[i];
 66 |             assetsList.add(sum);
 67 |         }
 68 | 
 69 |         return safetyCheck(null, null);
 70 |     }
 71 | 
 72 |     @PostMapping("/addRequest")
 73 |     public RestBean addRequest(@RequestBody AddRequestDto addRequestDto) {
 74 |         // 1.获取需要的资源
 75 |         request = addRequestDto.getRequestList();
 76 |         processNum = addRequestDto.getProcessNum();
 77 | 
 78 |         for (int i = 0; i< request.size(); i++) {
 79 |             // 2.判断有没有超过need
 80 |             if (request.get(i) > need[processNum][i])
 81 |                 return new RestBean<>(400, "对不起，系统出错");
 82 | 
 83 |             // 3.判断剩余资源是否充足 第一种阻塞情况
 84 |             if (request.get(i) > availableList.get(i))
 85 |                 return new RestBean<>(400, "剩余资源不足会引起进程" + (processNum + 1) + "处于阻塞状态");
 86 |         }
 87 | 
 88 |         // 4.尝试分配资源
 89 |         for (int i = 0; i< request.size(); i++) {
 90 |             need[processNum][i] = need[processNum][i] - request.get(i);
 91 |             allocation[processNum][i] = allocation[processNum][i] + request.get(i);
 92 |             availableList.set(i, availableList.get(i) - request.get(i));
 93 |         }
 94 | 
 95 |         // 执行安全算法
 96 |         return safetyCheck(processNum, request); //传入进程号和request
 97 |     }
 98 | 
 99 |     @PostMapping("/deleteRequest")
100 |     public RestBean deleteRequest(@RequestBody AddRequestDto addRequestDto) {
101 |         return null;
102 |     }
103 | 
104 |     @PostMapping("/addPro")
105 |     public RestBean addPro(@RequestBody AddRequestDto addRequestDto) {
106 |         processNum = addRequestDto.getProcessNum();
107 |         // 检查进程数是否已达到最大值
108 |         if (processesNumber >= 100)
109 |             return new RestBean(400, "添加失败，进程数已达到最大值");
110 | 
111 |         // 检查资源请求列表是否符合需求
112 |         List<Integer> requestList = addRequestDto.getRequestList();
113 |         for (int i = 0; i < assetsNumber; i++) {
114 |             if (requestList.get(i) > assetsList.get(i))
115 |                 return new RestBean(400, "添加失败，资源请求数超过资源总数");
116 |             if (requestList.get(i) > availableList.get(i))
117 |                 return new RestBean(400, "添加失败，资源请求数超过当前可用资源数");
118 |         }
119 | 
120 |         // 创建新线程
121 |         for (int i = 0; i < assetsNumber; i++) {
122 |             max[processNum][i] = requestList.get(i);
123 |             allocation[processNum][i] = 0;
124 |             need[processNum][i] = requestList.get(i);
125 |             availableList.set(i, availableList.get(i) - requestList.get(i));
126 |         }
127 |         processesNumber++;
128 |         return new RestBean(200, "添加成功");
129 |     }
130 | 
131 |     public RestBean safetyCheck(Integer process, List<Integer> request) {
132 | 
133 |         // 检查是否存在超出资源数量的最大需求
134 |         for (int i = 0; i < processesNumber; i++)
135 |             for (int j = 0; j < assetsNumber; j++)
136 |                 if (max[i][j] > assetsList.get(j))
137 |                     return new RestBean<>(400, "进程 " + (i + 1) + " 的最大需求超过了资源 " + (j + 1) + " 的总数");
138 | 
139 |         // 检查是否存在超出最大需求的分配情况
140 |         for (int i = 0; i < processesNumber; i++)
141 |             for (int j = 0; j < assetsNumber; j++)
142 |                 if (allocation[i][j] > max[i][j])
143 |                     return new RestBean<>(400, "进程 " + (i + 1) + " 的资源 " + (j + 1) + " 分配超过了最大需求");
144 | 
145 | 
146 |         // 检查是否存在超出资源数量的需求和分配情况
147 |         for (int i = 0; i < processesNumber; i++)
148 |             for (int j = 0; j < assetsNumber; j++)
149 |                 if (need[i][j] > assetsList.get(j) || allocation[i][j] > assetsList.get(j))
150 |                     return new RestBean<>(400, "进程 " + (i + 1) + " 的需求或分配超过了资源 " + (j + 1) + " 的总数");
151 | 
152 | 
153 |         // 检查是否所有资源都已经初始化
154 |         if (assetsList.contains(null))
155 |             return new RestBean<>(400, "请初始化所有资源");
156 | 
157 |         // 检查是否存在阻塞的进程
158 |         for(int i = 0; i < processesNumber; i++) {
159 |             // 检查进程是否满足需求
160 |             boolean isSafe = true;
161 |             for (int j = 0; j < assetsNumber; j++) {
162 |                 if (need[i][j] > assetsList.get(j)) {
163 |                     isSafe = false;
164 |                     break;
165 |                 }
166 |             }
167 |             if (!isSafe)
168 |                 return new RestBean<>(400, "进程 " + (i + 1) + " 阻塞");
169 |         }
170 | 
171 |         int[] work = new int[assetsNumber];
172 |         boolean[] finish = new boolean[processesNumber];
173 |         List<Integer> safeSeq = new ArrayList<>();
174 | 
175 |         // 初始化work为available
176 |         for (int i = 0; i < assetsNumber; i++) {
177 |             work[i] = availableList.get(i);
178 |         }
179 | 
180 |         // 初始化完成状态
181 |         for (int i = 0; i < processesNumber; i++)
182 |             finish[i] = false;
183 | 
184 |         int count = 0; // 计数器
185 | 
186 |         // 遍历所有进程
187 |         while (count < processesNumber) {
188 |             boolean found = false;
189 |             for (int i = 0; i < processesNumber; i++) {
190 |                 if (!finish[i]) {
191 |                     boolean canExecute = true;
192 |                     for (int j = 0; j < assetsNumber; j++) {
193 |                         if (need[i][j] > work[j]) {
194 |                             canExecute = false;
195 |                             break;
196 |                         }
197 |                     }
198 |                     if (canExecute) {
199 |                         for (int j = 0; j < assetsNumber; j++) {
200 |                             work[j] += allocation[i][j];
201 |                         }
202 |                         safeSeq.add(i);
203 |                         finish[i] = true;
204 |                         found = true;
205 |                         count++;
206 |                     }
207 |                 }
208 |             }
209 | 
210 |             // 没有找到可以执行的进程，说明系统处于不安全状态
211 |             if (!found) {
212 |                 safeSeq.clear();
213 |                 break;
214 |             }
215 |         }
216 |         if (safeSeq.isEmpty()) {
217 |             if (process == null) {
218 |                 return new RestBean<>(201, "系统处于不安全状态");
219 |             }
220 |             else {
221 |                 // 7. 不安全，则阻塞，第二种阻塞情况
222 |                 // 回滚数据
223 |                 for (int i = 0; i< request.size(); i++) {
224 |                     need[processNum][i] = need[processNum][i] + request.get(i);
225 |                     allocation[processNum][i] = allocation[processNum][i] - request.get(i);
226 |                     availableList.set(i, availableList.get(i) + request.get(i));
227 |                 }
228 |                 String str = "进程" + (process + 1) + "处于阻塞状态";
229 |                 return new RestBean<>(400, "系统处于不安全状态," + str);
230 |             }
231 |         } else {
232 |             // 6. 安全， 正式分配
233 |             return new RestBean<>(200, safeSeq);
234 |         }
235 |     }
236 | }
237 | 


--------------------------------------------------------------------------------
/src/main/resources/static/index.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
  2 |         "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
  3 | <html xmlns="http://www.w3.org/1999/xhtml">
  4 | <head>
  5 |     <meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
  6 |     <title>银行家算法模拟系统</title>
  7 |     <script src="https://unpkg.com/axios/dist/axios.min.js"></script>
  8 |     <script>
  9 |         const request = axios.create({
 10 |             baseURL: 'http://localhost:8080',
 11 |             timeout: 5000
 12 |         })
 13 | 
 14 |         function init() {
 15 |             let param = {
 16 |                 "processesNumber": parseInt(document.getElementById("processes").value),
 17 |                 "assetsNumber": parseInt(document.getElementById("assets").value)
 18 |             }
 19 |             request.post("/bank/initNumber", param).then(res => {
 20 |                 if (res.status === 200) {
 21 |                     if (res.data.code === 200) {
 22 |                         document.getElementById("inputAssets").innerHTML = "请输入每个资源对应的available"
 23 |                         let inputAssetsBody = document.getElementById("inputAssetsBody");
 24 | 
 25 |                         for (let i = 1; i <= param.assetsNumber; i++) {
 26 |                             let newElement = document.createElement("p");
 27 |                             let textNode = document.createTextNode("资源 " + i + ": ");
 28 |                             newElement.appendChild(textNode);
 29 |                             let inputField = document.createElement("input");
 30 |                             inputField.type = "text";
 31 |                             inputField.id = "assets" + i
 32 |                             newElement.insertBefore(inputField, textNode.nextSibling);
 33 |                             inputAssetsBody.appendChild(newElement);
 34 |                         }
 35 |                         let button = document.createElement("button");
 36 |                         button.innerHTML = "确认"
 37 |                         button.onclick = function() {
 38 |                             let params = []
 39 |                             for (let i = 1; i <= param.assetsNumber ; i++) {
 40 |                                 params.push(parseInt(document.getElementById("assets" + i).value))
 41 |                             }
 42 |                             for (let i = 0; i < params.length; i++) {
 43 |                                 if (isNaN(params.at(i))) {
 44 |                                     window.alert("请检查参数是否正确")
 45 |                                     return
 46 |                                 }
 47 |                             }
 48 |                             request.post("/bank/initAssets", params).then(r => {
 49 |                                 if (r.status === 200) {
 50 |                                     if (r.data.code === 200) {
 51 |                                         var inputMaxAndAll = document.getElementById("inputMaxAndAll");
 52 |                                         inputMaxAndAll.innerHTML = "请输入对应需求和分配情况"
 53 |                                         let processName = document.getElementById("processName");
 54 |                                         let maxInfo = document.getElementById("maxInfo");
 55 |                                         let allocationInfo = document.getElementById("allocationInfo");
 56 |                                         let needInfo = document.getElementById("needInfo");
 57 |                                         let finalButton = document.getElementById("finalButton");
 58 |                                         processName.style.display = "block"
 59 |                                         maxInfo.style.display = "block"
 60 |                                         allocationInfo.style.display = "block"
 61 |                                         needInfo.style.display = "block"
 62 |                                         finalButton.style.display = "inline-block"
 63 |                                         finalButton.onclick = function () {
 64 |                                             let need = []
 65 |                                             let max = []
 66 |                                             let allocation = []
 67 |                                             for (let i = 0; i < param.processesNumber; i++) {
 68 |                                                 for (let j = 0; j < param.assetsNumber; j++) {
 69 |                                                     let maxNumber = parseInt(document.getElementById(i + "maxNumber" + j).value)
 70 |                                                     let allocationNumber = parseInt(document.getElementById(i + "allocationNumber" + j).value)
 71 |                                                     if (isNaN(maxNumber) || isNaN(allocationNumber)) {
 72 |                                                         window.alert("请检查参数是否正确")
 73 |                                                         return
 74 |                                                     }
 75 |                                                     max.push(maxNumber)
 76 |                                                     allocation.push(allocationNumber)
 77 |                                                     need.push(maxNumber - allocationNumber)
 78 |                                                 }
 79 |                                             }
 80 |                                             for (let i = 0; i < (need.length / param.assetsNumber); i++) {
 81 |                                                 let div = document.createElement("div")
 82 |                                                 div.style.width = "100%"
 83 |                                                 div.style.height = "30px"
 84 |                                                 div.style.marginTop = "5px"
 85 |                                                 div.style.display = "flex"
 86 |                                                 for (let j = 0; j < param.assetsNumber; j++) {
 87 |                                                     let divSon = document.createElement("div")
 88 |                                                     divSon.style.width = "30px"
 89 |                                                     divSon.style.marginRight = "5px"
 90 |                                                     divSon.innerHTML = need.at(i * param.assetsNumber + j)
 91 |                                                     div.appendChild(divSon)
 92 |                                                 }
 93 |                                                 needInfo.appendChild(div)
 94 |                                             }
 95 |                                             let paramInfo = {
 96 |                                                 "max": max,
 97 |                                                 "allocation": allocation,
 98 |                                                 "need" : need
 99 |                                             }
100 |                                             request.post("/bank/initOtherAndMath", paramInfo).then(result => {
101 |                                                 if (result.status === 200) {
102 |                                                     let resultElement = document.getElementById("result");
103 |                                                     needInfo.innerHTML = "Need(无须输入，确认后自动算出)"
104 |                                                     for (let i = 0; i < (need.length / param.assetsNumber); i++) {
105 |                                                         let div = document.createElement("div")
106 |                                                         div.style.width = "100%"
107 |                                                         div.style.height = "30px"
108 |                                                         div.style.marginTop = "5px"
109 |                                                         div.style.display = "flex"
110 |                                                         for (let j = 0; j < param.assetsNumber; j++) {
111 |                                                             let divSon = document.createElement("div")
112 |                                                             divSon.style.width = "30px"
113 |                                                             divSon.style.marginRight = "5px"
114 |                                                             divSon.id = i + "needDiv" + j
115 |                                                             divSon.innerHTML = need.at(i * param.assetsNumber + j)
116 |                                                             div.appendChild(divSon)
117 |                                                         }
118 |                                                         needInfo.appendChild(div)
119 |                                                     }
120 |                                                     if (result.data.code === 200) {
121 |                                                         let str = "该资源是安全的;安全序列为:"
122 |                                                         for (let i = 1; i < result.data.data.length ; i++) {
123 |                                                             str = str + result.data.data.at(i - 1) + "=>"
124 |                                                         }
125 |                                                         str = str + result.data.data.at(result.data.data.length - 1)
126 |                                                         resultElement.innerHTML = str
127 |                                                         let requestTitle = document.getElementById("request");
128 |                                                         requestTitle.innerHTML = "请选择接下来的操作"
129 |                                                         let requestDiv = document.getElementById("requestDiv");
130 |                                                         requestDiv.style.display = "block"
131 |                                                         let applyMain = document.getElementById("apply");
132 |                                                         let applyPro = document.createElement("div");
133 |                                                         applyPro.style.marginLeft = "40%"
134 |                                                         applyPro.innerHTML = "请选择申请的进程名："
135 |                                                         applyMain.appendChild(applyPro)
136 |                                                         let selectApply = document.createElement("select");
137 |                                                         selectApply.id = "selectApply"
138 |                                                         selectApply.style.height = "25px"
139 |                                                         for (let i = 0; i < param.processesNumber; i++) {
140 |                                                             const newOption = document.createElement("option");
141 |                                                             newOption.value = i;
142 |                                                             newOption.text = "进程" + (i + 1);
143 |                                                             selectApply.appendChild(newOption)
144 |                                                         }
145 |                                                         applyMain.appendChild(selectApply)
146 |                                                         let applyDoc = document.createElement("div");
147 |                                                         applyDoc.style.marginLeft = "5px"
148 |                                                         applyDoc.style.marginRight = "5px"
149 |                                                         applyDoc.innerHTML = "请输入申请资源数："
150 |                                                         applyMain.appendChild(applyDoc)
151 |                                                         for (let j = 0; j < param.assetsNumber; j++) {
152 |                                                             let input = document.createElement("input");
153 |                                                             input.type = "text";
154 |                                                             input.style.height = "15px"
155 |                                                             input.style.width = "30px"
156 |                                                             input.style.marginLeft = "5px"
157 |                                                             input.id = "selectApply" + j
158 |                                                             applyMain.appendChild(input);
159 |                                                         }
160 |                                                         let applyButton = document.createElement("button");
161 |                                                         applyButton.style.marginLeft = "5px"
162 |                                                         applyButton.style.width = "50px"
163 |                                                         applyButton.style.height = "25px"
164 |                                                         applyButton.innerHTML = "确认"
165 |                                                         applyButton.onclick = function () {
166 |                                                             let requestList = []
167 |                                                             for (let i = 0; i < param.assetsNumber; i++) {
168 |                                                                 if (isNaN(parseInt(document.getElementById("selectApply" + i).value)))
169 |                                                                     window.alert("请检测参数是否正确")
170 |                                                                 else
171 |                                                                     requestList.push(parseInt(document.getElementById("selectApply" + i).value))
172 |                                                             }
173 |                                                             let requestParam = {
174 |                                                                 processNum: parseInt(document.getElementById("selectApply").value),
175 |                                                                 requestList: requestList
176 |                                                             }
177 |                                                             request.post("/bank/addRequest", requestParam).then(resultForAdd => {
178 |                                                                 if (resultForAdd.status === 200) {
179 |                                                                     if (resultForAdd.data.code === 200 || resultForAdd.data.code === 201) {
180 |                                                                         for (let i = 0; i < param.assetsNumber; i++) {
181 |                                                                             let elementById = document.getElementById(parseInt(document.getElementById("selectApply").value) + "allocationNumber" + i);
182 |                                                                             elementById.value = (parseInt(elementById.value) + requestList.at(i)).toString()
183 |                                                                             let elementById1 = document.getElementById(parseInt(document.getElementById("selectApply").value) + "needDiv" + i);
184 |                                                                             elementById1.innerHTML = (parseInt(elementById1.innerHTML) - requestList.at(i)).toString()
185 |                                                                             document.getElementById("assets" + (i + 1)).value = (parseInt(document.getElementById("assets" + (i + 1)).value) - requestList.at(i)).toString()
186 |                                                                         }
187 |                                                                         if (resultForAdd.data.code === 200) {
188 |                                                                             let str = "该资源是安全的;安全序列为:"
189 |                                                                             for (let i = 1; i < resultForAdd.data.data.length ; i++) {
190 |                                                                                 str = str + resultForAdd.data.data.at(i - 1) + "=>"
191 |                                                                             }
192 |                                                                             str = str + resultForAdd.data.data.at(resultForAdd.data.data.length - 1)
193 |                                                                             resultElement.innerHTML = str
194 |                                                                         } else {
195 |                                                                             resultElement.innerHTML = resultForAdd.data.data
196 |                                                                         }
197 |                                                                     } else {
198 |                                                                         resultElement.innerHTML = resultForAdd.data.data
199 |                                                                     }
200 |                                                                 }
201 |                                                             })
202 |                                                         }
203 |                                                         applyMain.appendChild(applyButton)
204 | 
205 |                                                         let releaseMain = document.getElementById("release");
206 |                                                         let releasePro = document.createElement("div");
207 |                                                         releasePro.style.marginLeft = "40%"
208 |                                                         releasePro.innerHTML = "请选择释放的进程名："
209 |                                                         releaseMain.appendChild(releasePro)
210 |                                                         let releaseRelease = document.createElement("select");
211 |                                                         releaseRelease.id = "selectRelease"
212 |                                                         releaseRelease.style.height = "25px"
213 |                                                         for (let i = 0; i < param.processesNumber; i++) {
214 |                                                             const newOption = document.createElement("option");
215 |                                                             newOption.value = i;
216 |                                                             newOption.text = "进程" + (i + 1);
217 |                                                             releaseRelease.appendChild(newOption)
218 |                                                         }
219 |                                                         releaseMain.appendChild(releaseRelease)
220 |                                                         let releaseButton = document.createElement("button");
221 |                                                         releaseButton.style.marginLeft = "5px"
222 |                                                         releaseButton.style.width = "50px"
223 |                                                         releaseButton.style.height = "25px"
224 |                                                         releaseButton.innerHTML = "确认"
225 |                                                         releaseButton.onclick = function () {
226 |                                                             let requestParam = {
227 |                                                                 processNum: parseInt(document.getElementById("selectRelease").value),
228 |                                                                 requestList: []
229 |                                                             }
230 |                                                             request.post("/bank/deleteRequest", requestParam).then(resultForAdd => {
231 |                                                                 console.log(resultForAdd)
232 |                                                             })
233 |                                                         }
234 |                                                         releaseMain.appendChild(releaseButton)
235 | 
236 |                                                         let addPro = document.getElementById("addPro");
237 |                                                         for (let j = 0; j < param.assetsNumber; j++) {
238 |                                                             let input = document.createElement("input");
239 |                                                             input.type = "text";
240 |                                                             input.style.height = "15px"
241 |                                                             input.style.width = "30px"
242 |                                                             input.style.marginLeft = "5px"
243 |                                                             input.id = "addPro" + j
244 |                                                             addPro.appendChild(input);
245 |                                                         }
246 |                                                         let addProButton = document.getElementById("addProButton")
247 |                                                         addProButton.onclick = function () {
248 |                                                             let addList = []
249 |                                                             for (let j = 0; j < param.assetsNumber; j++) {
250 |                                                                 let addProParam = document.getElementById("addPro" + j);
251 |                                                                 let value = parseInt(addProParam.value)
252 |                                                                 if (!isNaN(value))
253 |                                                                     addList.push(value)
254 |                                                                 else
255 |                                                                     window.alert("请检查参数")
256 |                                                             }
257 |                                                             let addParam = {
258 |                                                                 "processNum": (param.processesNumber + 1),
259 |                                                                 "requestList": addList
260 |                                                             }
261 |                                                             request.post("/bank/addPro", addParam).then(addResult => {
262 |                                                                 if (addResult.status === 200) {
263 |                                                                     if (addResult.data.code === 200) {
264 |                                                                         param.processesNumber += 1
265 |                                                                         let div = document.createElement("div")
266 |                                                                         div.style.width = "100%"
267 |                                                                         div.style.height = "30px"
268 |                                                                         div.style.marginTop = "5px"
269 |                                                                         div.innerHTML = "进程" + param.processesNumber
270 |                                                                         processName.appendChild(div)
271 |                                                                         let div2 = document.createElement("div")
272 |                                                                         div2.style.width = "100%"
273 |                                                                         div2.style.height = "30px"
274 |                                                                         div2.style.marginTop = "5px"
275 |                                                                         for (let j = 0; j < param.assetsNumber; j++) {
276 |                                                                             let input = document.createElement("input");
277 |                                                                             input.type = "text";
278 |                                                                             input.value = addList.at(j)
279 |                                                                             input.style.width = "30px"
280 |                                                                             input.style.marginRight = "5px"
281 |                                                                             input.id = param.processesNumber + "maxNumber" + j
282 |                                                                             div2.appendChild(input);
283 |                                                                         }
284 |                                                                         maxInfo.appendChild(div2)
285 |                                                                         let div3 = document.createElement("div")
286 |                                                                         div3.style.width = "100%"
287 |                                                                         div3.style.height = "30px"
288 |                                                                         div3.style.marginTop = "5px"
289 |                                                                         for (let j = 0; j < param.assetsNumber; j++) {
290 |                                                                             let input = document.createElement("input");
291 |                                                                             input.type = "text";
292 |                                                                             input.value = "0"
293 |                                                                             input.style.width = "30px"
294 |                                                                             input.style.marginRight = "5px"
295 |                                                                             input.id = param.processesNumber  + "allocationNumber" + j
296 |                                                                             div3.appendChild(input);
297 |                                                                         }
298 |                                                                         allocationInfo.appendChild(div3)
299 |                                                                         resultElement.innerHTML = "新增成功"
300 |                                                                     }
301 |                                                                     else
302 |                                                                         resultElement.innerHTML = addResult.data.data
303 |                                                                 }
304 |                                                             })
305 | 
306 |                                                         }
307 |                                                     } else {
308 |                                                         resultElement.innerHTML = result.data.data
309 |                                                     }
310 |                                                 }
311 |                                             })
312 |                                         }
313 |                                         for (let i = 1; i <= param.processesNumber; i++) {
314 |                                             let div = document.createElement("div")
315 |                                             div.style.width = "100%"
316 |                                             div.style.height = "30px"
317 |                                             div.style.marginTop = "5px"
318 |                                             div.innerHTML = "进程" + i
319 |                                             processName.appendChild(div)
320 |                                         }
321 |                                         for (let i = 0; i < param.processesNumber; i++) {
322 |                                             let div = document.createElement("div")
323 |                                             div.style.width = "100%"
324 |                                             div.style.height = "30px"
325 |                                             div.style.marginTop = "5px"
326 |                                             for (let j = 0; j < param.assetsNumber; j++) {
327 |                                                 let input = document.createElement("input");
328 |                                                 input.type = "text";
329 |                                                 input.style.width = "30px"
330 |                                                 input.style.marginRight = "5px"
331 |                                                 input.id = i + "maxNumber" + j
332 |                                                 div.appendChild(input);
333 |                                             }
334 |                                             maxInfo.appendChild(div)
335 |                                         }
336 |                                         for (let i = 0; i < param.processesNumber; i++) {
337 |                                             let div = document.createElement("div")
338 |                                             div.style.width = "100%"
339 |                                             div.style.height = "30px"
340 |                                             div.style.marginTop = "5px"
341 |                                             for (let j = 0; j < param.assetsNumber; j++) {
342 |                                                 let input = document.createElement("input");
343 |                                                 input.type = "text";
344 |                                                 input.style.width = "30px"
345 |                                                 input.style.marginRight = "5px"
346 |                                                 input.id = i + "allocationNumber" + j
347 |                                                 div.appendChild(input);
348 |                                             }
349 |                                             allocationInfo.appendChild(div)
350 |                                         }
351 |                                     }
352 |                                 } else {
353 |                                     window.alert(res.data.data)
354 |                                 }
355 |                             })
356 |                         }
357 |                         inputAssetsBody.appendChild(button)
358 |                     } else {
359 |                         window.alert(res.data.data)
360 |                     }
361 |                 }
362 |             })
363 |         }
364 | 
365 |     function reload() {
366 |         window.location.reload()
367 |     }
368 | 
369 |     </script>
370 | </head>
371 | 
372 | <body>
373 | <div style="width: 100%; height: 100%; text-align: center">
374 |     请输入进程数:
375 |     <input type="text" id="processes" style="margin-top: 10px"/><br/>
376 |     请输入资源数:
377 |     <input type="text" id="assets" style="margin-top: 10px"/><br/>
378 |     <button id="initButton" style="width:50px; margin-top: 10px" onclick="init()">
379 |         确认
380 |     </button>
381 |     <h4 id="inputAssets"></h4>
382 |     <div id="inputAssetsBody">
383 |     </div>
384 |     <h4 id="inputMaxAndAll"></h4>
385 |     <div id="mainTable" style="display: flex">
386 |         <div id="processName" style="width: 10%; display: none">
387 |             进程名
388 |         </div>
389 |         <div id="maxInfo" style="width: 30%; display: none">
390 |             Max
391 |         </div>
392 |         <div id="allocationInfo" style="width: 30%; display: none">
393 |             Allocation
394 |         </div>
395 |         <div id="needInfo" style="width: 30%; display: none">
396 |             Need(无须输入，确认后自动算出)
397 |         </div>
398 |     </div>
399 |     <button id="finalButton" style="width:50px; display: none; margin-top: 10px">确认</button>
400 |     <h3 id="result" style="margin-top: 10px"></h3>
401 |     <h4 id="request"></h4>
402 |     <div id="requestDiv" style="display: none">
403 |         <div id="applyProcess">
404 |             <div>
405 |                 申请资源
406 |             </div>
407 |             <div id="apply" style="display: flex">
408 |             </div>
409 |         </div>
410 |         <div id="releaseProcess">
411 |             释放资源
412 |             <div id="release" style="display: flex">
413 |             </div>
414 |         </div>
415 |         <div id="addProcess">
416 |             新增线程
417 |             <div id="add" style="display: flex">
418 |                 <div style="margin-left: 40%">请输入新建资源的max分配情况</div>
419 |                 <div  id="addPro" style="margin-left: 10px"></div>
420 |                 <button id="addProButton" style="margin-left: 10px">新建进程</button>
421 |             </div>
422 |         </div>
423 |         <div>
424 |             <button style="width:50px; margin-top: 10px" onclick="reload()">
425 |                 重开
426 |             </button>
427 |         </div>
428 |     </div>
429 | </div>
430 | </body>
431 | </html>


--------------------------------------------------------------------------------