package deceive_allocation;
import java.util.*;
import java.util.concurrent.ConcurrentLinkedDeque;
import java.util.concurrent.LinkedBlockingQueue;
/**
* @author lele
* @title 设备分配流程
* @date 2020-11-2
*/
public class DeceiveAllocationFlow {
public static void main(String[] args) throws InterruptedException {
//初始化设备信息
/*测试数据一：
CHCT channel1 = new CHCT("channel1", "闲");
CHCT channel2 = new CHCT("channel2", "闲");
CHCT channel3 = new CHCT("channel3", "闲");
List<CHCT> channelsOfController1 = new ArrayList<>();
channelsOfController1.add(channel1);
channelsOfController1.add(channel2);
COCT controller1 = new COCT("controller1", "闲", channelsOfController1);
List<CHCT> channelsOfController2 = new ArrayList<>();
channelsOfController2.add(channel2);
COCT controller2 = new COCT("controller2", "闲", channelsOfController2);
List<CHCT> channelsOfController3 = new ArrayList<>();
channelsOfController3.add(channel3);
COCT controller3 = new COCT("controller3", "闲", channelsOfController3);
List<COCT> controllerOfDeceive1 = new ArrayList<>();
controllerOfDeceive1.add(controller1);
controllerOfDeceive1.add(controller2);
DCT deceive1 = new DCT("deceive1", "闲", controllerOfDeceive1);
List<COCT> controllerOfDeceive2 = new ArrayList<>();
controllerOfDeceive2.add(controller2);
controllerOfDeceive2.add(controller3);
DCT deceive2 = new DCT("deceive2", "闲", controllerOfDeceive2);
List<COCT> controllerOfDeceive3 = new ArrayList<>();
controllerOfDeceive3.add(controller3);
DCT deceive3 = new DCT("deceive3", "闲", controllerOfDeceive3);
//将设备添加到系统设备表
SDT sdt = new SDT();
sdt.dcts.add(deceive1);
sdt.dcts.add(deceive2);
sdt.dcts.add(deceive3);
//打印设备信息
sdt.printDeceiveInfo();
process1 deceive1
process2 deceive1
process3 deceive3
process4 deceive2
*/
CHCT channel1 = new CHCT("channel1", "闲");
CHCT channel2 = new CHCT("channel2", "闲");
CHCT channel3 = new CHCT("channel3", "闲");
List<CHCT> channelsOfController1 = new ArrayList<>();
channelsOfController1.add(channel1);
channelsOfController1.add(channel2);
COCT controller1 = new COCT("controller1", "闲", channelsOfController1);
List<CHCT> channelsOfController2 = new ArrayList<>();
channelsOfController2.add(channel2);
channelsOfController2.add(channel3);
COCT controller2 = new COCT("controller2", "闲", channelsOfController2);
List<COCT> controllerOfDeceive1 = new ArrayList<>();
controllerOfDeceive1.add(controller1);
controllerOfDeceive1.add(controller2);
DCT deceive1 = new DCT("deceive1", "闲", controllerOfDeceive1);
List<COCT> controllerOfDeceive2 = new ArrayList<>();
controllerOfDeceive2.add(controller2);
DCT deceive2 = new DCT("deceive2", "闲", controllerOfDeceive2);
List<COCT> controllerOfDeceive3 = new ArrayList<>();
controllerOfDeceive3.add(controller2);
DCT deceive3 = new DCT("deceive3", "闲", controllerOfDeceive3);
/*
测试数据
process2 deceive2
process3 deceive3
*/
//将设备添加到系统设备表
SDT sdt = new SDT();
sdt.dcts.add(deceive1);
sdt.dcts.add(deceive2);
sdt.dcts.add(deceive3);
//打印设备信息
sdt.printDeceiveInfo();
Scanner in = new Scanner(System.in);
sdt.executeWaitQueueProcess();
while (true) {
Process process = new Process();
process.dctId = process.coctId = process.chctId = -1;
process.identifier = in.next();//输入进程标识
process.deceiveIdentifier = in.next();//输入进程请求的设备标识
sdt.requestDeceive(process);//请求设备
}
}
}
class Process {
String identifier;
Integer dctId;
Integer coctId;
Integer chctId;
String deceiveIdentifier;
}
//系统设备表：记录系统中全部设备的信息
class SDT {
volatile List<DCT> dcts = new ArrayList<>();
void printDeceiveInfo() {
for (DCT dct : dcts) {
for (COCT coct : dct.cocts) {
for (CHCT chct : coct.chcts) {
System.out.println(" 设备标识：" + dct.identifier + " 状态：" + dct.state +
" 控制器标识：" + coct.identifier + " 状态：" + coct.state + " 通道标识：" + chct.identifier + " 状态：" + chct.state);
}
}
}
}
void executeWaitQueueProcess() {
new Thread(() -> {
while (true) {
//轮训各个设备的等待队列
for (DCT dct : dcts) {
if (!dct.waitQueue.isEmpty() && dct.state.equals("闲")) {
//若该设备的等待队列中有请求的进程且当前设备状态为闲置时
Process poll = dct.waitQueue.poll();//该请求进程出栈
try {
System.out.println(poll.deceiveIdentifier + " 等待队列：" + poll.identifier + "已占用此设备...");
requestDeceive(poll);//继续分配控制器
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}).start();
new Thread(() -> {
while (true) {
for (DCT dct : dcts) {
//轮训各个设备的控制器
if (!dct.controllerWaitQueue.isEmpty()) {
//若有进程已占用设备，但为占用控制器时
for (COCT coct : dct.cocts) {
//遍历该设备所有的控制器
if (coct.state.equals("闲")) {
//当有一个控制器是空闲时
Process poll = dct.controllerWaitQueue.poll();//则将等待进程出栈
try {
System.out.println(poll.deceiveIdentifier + "设备已请求到控制器成功...");
requestDeceive(poll);
break;
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}
}).start();
new Thread(() -> {
while (true) {
for (DCT dct : dcts) {
for (COCT coct : dct.cocts) {
if (!coct.channelWaitQueue.isEmpty()) {
for (CHCT chct : coct.chcts) {
if (chct.state.equals("闲")) {
Process poll = coct.channelWaitQueue.poll();
try {
System.out.println(poll.deceiveIdentifier + "设备已请求到通道成功...");
requestDeceive(poll);
break;
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}
}
}).start();
}
void requestDeceive(Process process) throws InterruptedException {
new Thread(() -> {
if (process.dctId == -1) {
boolean flag = false;
int i;
for (i = 0; i < dcts.size(); i++) {
if (dcts.get(i).identifier.equals(process.deceiveIdentifier)) {
if (dcts.get(i).state.equals("闲")) {
flag = true;
} else {
flag = false;
}
break;
}
}
if (flag) {
dcts.get(i).state = "忙";
process.dctId = i;
} else {
dcts.get(i).waitQueue.add(process);
System.out.println(process.identifier + ": 请求的设备:" + process.deceiveIdentifier + "已被占用,已加入请求队列等待...");
return;
}
}
if (process.coctId == -1) {
List<COCT> cocts = dcts.get(process.dctId).cocts;
int i;
for (i = 0; i < cocts.size(); i++) {
if (cocts.get(i).state.equals("闲")) {
break;
}
}
if (i < cocts.size()) {
cocts.get(i).state = "忙";
process.coctId = i;
} else {
dcts.get(process.dctId).controllerWaitQueue.add(process);
System.out.println(process.deceiveIdentifier + ":设备所需的控制器已全部被占用，已加入请求队列等待...");
return;
}
}
if (process.chctId == -1) {
List<CHCT> chcts = dcts.get(process.dctId).cocts.get(process.coctId).chcts;
int i;
for (i = 0; i < chcts.size(); i++) {
if (chcts.get(i).state.equals("闲")) {
break;
}
}
if (i < chcts.size()) {
chcts.get(i).state = "忙";
process.chctId = i;
} else {
dcts.get(process.dctId).cocts.get(process.chctId).channelWaitQueue.add(process);
System.out.println(process.deceiveIdentifier + ":设备所需的通道已全部被占用，已加入请求队列等待...");
return;
}
}
//执行
System.out.println(process.identifier + ":请求设备：" + process.deceiveIdentifier + "成功！");
//打印状态信息
printDeceiveInfo();
try {
Thread.sleep(8000 + new Random().nextInt(8000));
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(process.identifier + ":使用设备：" + process.deceiveIdentifier + "完成！");
dcts.get(process.dctId).state = "闲";
dcts.get(process.dctId).cocts.get(process.coctId).state = "闲";
dcts.get(process.dctId).cocts.get(process.coctId).chcts.get(process.chctId).state = "闲";
}).start();
}
}
//设备控制表：记录该设备的情况
class DCT {
String identifier;//设备标识符
String state;//设备状态
volatile Queue<Process> waitQueue = new LinkedBlockingQueue<>();//进程设备请求队列
List<COCT> cocts = new ArrayList<>();//控制器表
volatile Queue<Process> controllerWaitQueue = new ConcurrentLinkedDeque();//控制器等待队列指针
public DCT(String identifier, String state, List<COCT> cocts) {
this.identifier = identifier;
this.state = state;
this.cocts = cocts;
}
}
//控制器控制表：为每一个控制器都配置了用于记录本控制器情况的控制器控制表
class COCT {
String identifier;//
// 控制器标识符
String state;//控制器状态
List<CHCT> chcts = new ArrayList<>();//通道控制表
volatile Queue<Process> channelWaitQueue = new ConcurrentLinkedDeque<>();//设备等待队列指针
public COCT(String identifier, String state, List<CHCT> chcts) {
this.identifier = identifier;
this.state = state;
this.chcts = chcts;
}
}
//通道控制表：为每一个通道都配置了一张用于记录本通道情况的通道控制表
class CHCT {
String identifier;//通道标识符
String state;//通道状态
public CHCT(String identifier, String state) {
this.identifier = identifier;
this.state = state;
}
}