359 lines
14 KiB
Java
359 lines
14 KiB
Java
package com.ruoyi.schedule;
|
|
|
|
import HslCommunication.Core.Types.OperateResultExOne;
|
|
import com.ruoyi.common.domain.CustomThread;
|
|
import com.ruoyi.common.domain.PlcConnectInfo;
|
|
import com.ruoyi.device.cdz.domain.DeviceCdz;
|
|
import com.ruoyi.device.cdz.service.IDeviceCdzService;
|
|
import com.ruoyi.device.ddj.domain.MsgDdj;
|
|
import com.ruoyi.device.ddj.service.IMsgDdjService;
|
|
import com.ruoyi.device.srgv.domain.DeviceSrgv;
|
|
import com.ruoyi.device.srgv.service.IDeviceSrgvService;
|
|
import com.ruoyi.device.ssj.domain.DeviceSsj;
|
|
import com.ruoyi.device.ssj.service.IDeviceSsjService;
|
|
import com.ruoyi.device.tsj.domain.DeviceTsj;
|
|
import com.ruoyi.device.tsj.service.impl.DeviceTsjServiceImpl;
|
|
import com.ruoyi.schedule.plcRead.cdz.PlcCdzRead;
|
|
import com.ruoyi.schedule.plcRead.ddj.PlcDdjRead;
|
|
import com.ruoyi.schedule.plcRead.srgv.PlcSrgvRead;
|
|
import com.ruoyi.schedule.plcRead.ssj.PlcSsjRead;
|
|
import com.ruoyi.schedule.plcRead.tsj.PlcTsjRead;
|
|
import com.ruoyi.schedule.scheduleTask.cdz.CdzThread;
|
|
import com.ruoyi.schedule.scheduleTask.ddj.impl.Ddj1Thread;
|
|
import com.ruoyi.schedule.scheduleTask.monit.MonitoringThread;
|
|
import com.ruoyi.schedule.scheduleTask.srgv.impl.SRgv1Thread;
|
|
import com.ruoyi.schedule.scheduleTask.ssj.SsjThread;
|
|
import com.ruoyi.schedule.scheduleTask.tsj.TsjThread;
|
|
import lombok.extern.slf4j.Slf4j;
|
|
import org.springframework.beans.factory.annotation.Autowired;
|
|
import org.springframework.stereotype.Component;
|
|
|
|
import javax.annotation.PostConstruct;
|
|
import javax.annotation.PreDestroy;
|
|
import java.lang.reflect.Field;
|
|
import java.util.ArrayList;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.concurrent.ConcurrentHashMap;
|
|
|
|
@Component
|
|
@Slf4j
|
|
public class ScheduleThread {
|
|
|
|
public Map<String, CustomThread<?>> threadMap = new ConcurrentHashMap<>();
|
|
public Map<String, String> threadDescMap = new ConcurrentHashMap<>();
|
|
public Map<String, String> threadTypeMap = new ConcurrentHashMap<>();
|
|
|
|
public CustomThread<PlcSsjRead> plcSsjReadCustomThread;
|
|
public CustomThread<PlcCdzRead> plcCdzjReadCustomThread;
|
|
public CustomThread<PlcTsjRead> plcTsjReadCustomThread;
|
|
public CustomThread<PlcSrgvRead> plcSrgvReadCustomThread1;
|
|
public CustomThread<PlcSrgvRead> plcSrgvReadCustomThread2;
|
|
public CustomThread<PlcSrgvRead> plcSrgvReadCustomThread3;
|
|
|
|
public CustomThread<MonitoringThread> monitoringCustomThread;
|
|
public CustomThread<SsjThread> ssjThreadCustomThread;
|
|
public CustomThread<SRgv1Thread> sRgvThreadCustomThread;
|
|
public CustomThread<TsjThread> tsjThreadCustomThread;
|
|
public CustomThread<CdzThread> cdzThreadCustomThread;
|
|
|
|
@Autowired
|
|
private IDeviceSsjService deviceSsjService;
|
|
@Autowired
|
|
private IDeviceSrgvService deviceSrgvService;
|
|
|
|
@Autowired
|
|
private IDeviceCdzService deviceCdzService;
|
|
|
|
private boolean isRun = false;
|
|
private boolean isRun2 = false;
|
|
@Autowired
|
|
private DeviceTsjServiceImpl deviceTsjServiceImpl;
|
|
|
|
/**
|
|
* 项目初始化启动
|
|
*/
|
|
@PostConstruct
|
|
public void init() {
|
|
log.info("初始化调度服务");
|
|
//读取信息初始化
|
|
plcReadInit();
|
|
//调度初始化
|
|
scheduleInit();
|
|
|
|
startAllThread();
|
|
|
|
startAllThread2();
|
|
|
|
log.info("调度服务执行成功");
|
|
}
|
|
|
|
@PreDestroy
|
|
public void destroy() {
|
|
try {
|
|
for (String key : threadMap.keySet()) {
|
|
CustomThread<?> ct = threadMap.get(key);
|
|
if (ct != null && ct.getRunnable() != null) {
|
|
setRunnableIsRun(ct.getRunnable(), false);
|
|
}
|
|
}
|
|
for (String key : threadMap.keySet()) {
|
|
CustomThread<?> ct = threadMap.get(key);
|
|
if (ct != null && ct.getThread() != null) {
|
|
try {
|
|
ct.getThread().join(2000);
|
|
} catch (InterruptedException ignored) {
|
|
Thread.currentThread().interrupt();
|
|
}
|
|
}
|
|
}
|
|
} catch (Exception e) {
|
|
log.error("调度服务销毁时停止线程异常", e);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 调度初始化
|
|
*/
|
|
private void scheduleInit() {
|
|
//输送机线程
|
|
SsjThread ssjThread = new SsjThread();
|
|
ssjThreadCustomThread = new CustomThread<SsjThread>(new Thread(ssjThread, "ssjThreadCustomThread"), ssjThread);
|
|
//四向车线程
|
|
SRgv1Thread srgvThread = new SRgv1Thread();
|
|
sRgvThreadCustomThread = new CustomThread<>(new Thread(srgvThread, "sRgvThreadCustomThread"), srgvThread);
|
|
//提升机线程
|
|
TsjThread tsjThread = new TsjThread();
|
|
tsjThreadCustomThread = new CustomThread<>(new Thread(tsjThread, "tsjThreadCustomThread"), tsjThread);
|
|
//充电线程
|
|
CdzThread cdzThread = new CdzThread();
|
|
cdzThreadCustomThread = new CustomThread<>(new Thread(cdzThread, "cdzThreadCustomThread"), cdzThread);
|
|
|
|
refreshThreadMap();
|
|
}
|
|
|
|
/**
|
|
* plc读取初始化
|
|
*/
|
|
private void plcReadInit() {
|
|
//plc输送机读取线程
|
|
ConcurrentHashMap<String, DeviceSsj> ssjList = new ConcurrentHashMap<>();
|
|
//获取要取的输送机
|
|
List<DeviceSsj> deviceSsjs = deviceSsjService.selectDeviceSsjList(new DeviceSsj());
|
|
for (DeviceSsj deviceSsj : deviceSsjs) {
|
|
ssjList.put(deviceSsj.getDeviceCode(), deviceSsj);
|
|
}
|
|
PlcSsjRead plcSsjRead = new PlcSsjRead(ssjList, new PlcConnectInfo("192.168.10.100", 502));
|
|
Thread plcSsjReadThread = new Thread(plcSsjRead, "plcSsjReadCustomThread");
|
|
plcSsjReadCustomThread = new CustomThread<PlcSsjRead>(plcSsjReadThread, plcSsjRead);
|
|
|
|
//plc充电桩读取线程
|
|
ConcurrentHashMap<String, DeviceCdz> cdzList = new ConcurrentHashMap<>();
|
|
List<DeviceCdz> deviceCdzList = deviceCdzService.selectDeviceCdzList(new DeviceCdz());
|
|
for (DeviceCdz deviceCdz : deviceCdzList) {
|
|
cdzList.put(String.valueOf(deviceCdz.getId()), deviceCdz);
|
|
}
|
|
PlcCdzRead plcCdzRead = new PlcCdzRead(cdzList, new PlcConnectInfo("192.168.10.100", 502));
|
|
Thread plcCdzReadThread = new Thread(plcCdzRead, "plcCdzjReadCustomThread");
|
|
plcCdzjReadCustomThread = new CustomThread<PlcCdzRead>(plcCdzReadThread, plcCdzRead);
|
|
|
|
|
|
ConcurrentHashMap<String, DeviceTsj> tsjList = new ConcurrentHashMap<>();
|
|
//获取要取的提升机
|
|
List<DeviceTsj> tsjLists = deviceTsjServiceImpl.selectDeviceTsjList(new DeviceTsj());
|
|
for (DeviceTsj t : tsjLists) {
|
|
tsjList.put(t.getName(), t);
|
|
}
|
|
//plc提升机读取线程
|
|
PlcTsjRead plcTsjRead = new PlcTsjRead(tsjList, new PlcConnectInfo("192.168.10.100", 502));
|
|
Thread plcTsjReadThread = new Thread(plcTsjRead, "plcTsjReadCustomThread");
|
|
plcTsjReadCustomThread = new CustomThread<PlcTsjRead>(plcTsjReadThread, plcTsjRead);
|
|
|
|
ConcurrentHashMap<String, DeviceSrgv> srgvList = new ConcurrentHashMap<>();
|
|
List<DeviceSrgv> srgvs = deviceSrgvService.selectDeviceSrgvList(new DeviceSrgv());
|
|
for (DeviceSrgv srgv : srgvs) {
|
|
switch (srgv.getDeviceId()) {
|
|
case 1:
|
|
PlcSrgvRead plcSrgvRead1 = new PlcSrgvRead(srgv, new PlcConnectInfo(srgv.getIp(), srgv.getPort()));
|
|
Thread plcSrgvReadThread1 = new Thread(plcSrgvRead1, "plcSrgvReadCustomThread1");
|
|
plcSrgvReadCustomThread1 = new CustomThread<PlcSrgvRead>(plcSrgvReadThread1, plcSrgvRead1);
|
|
break;
|
|
case 2:
|
|
PlcSrgvRead plcSrgvRead2 = new PlcSrgvRead(srgv, new PlcConnectInfo(srgv.getIp(), srgv.getPort()));
|
|
Thread plcSrgvReadThread2 = new Thread(plcSrgvRead2, "plcSrgvReadCustomThread2");
|
|
plcSrgvReadCustomThread2 = new CustomThread<PlcSrgvRead>(plcSrgvReadThread2, plcSrgvRead2);
|
|
break;
|
|
}
|
|
srgvList.put(srgv.getDeviceId().toString(), srgv);
|
|
}
|
|
PlcSrgvRead.deviceSrgvMap = srgvList;
|
|
//监控线程
|
|
MonitoringThread monitoringThread = new MonitoringThread();
|
|
monitoringCustomThread = new CustomThread<MonitoringThread>(new Thread(monitoringThread, "monitoringCustomThread"), monitoringThread);
|
|
|
|
refreshThreadMap();
|
|
}
|
|
|
|
public void refreshThreadMap() {
|
|
registerThread("plcSsjReadCustomThread", plcSsjReadCustomThread, "PLC输送机读取线程", "read");
|
|
registerThread("plcCdzjReadCustomThread", plcCdzjReadCustomThread, "PLC充电桩读取线程", "read");
|
|
registerThread("plcTsjReadCustomThread", plcTsjReadCustomThread, "PLC提升机读取线程", "read");
|
|
registerThread("plcSrgvReadCustomThread1", plcSrgvReadCustomThread1, "PLC四向车1读取线程", "read");
|
|
registerThread("plcSrgvReadCustomThread2", plcSrgvReadCustomThread2, "PLC四向车2读取线程", "read");
|
|
registerThread("monitoringCustomThread", monitoringCustomThread, "监控线程", "monitor");
|
|
registerThread("ssjThreadCustomThread", ssjThreadCustomThread, "输送机调度线程", "schedule");
|
|
registerThread("sRgvThreadCustomThread", sRgvThreadCustomThread, "四向车调度线程", "schedule");
|
|
registerThread("tsjThreadCustomThread", tsjThreadCustomThread, "提升机调度线程", "schedule");
|
|
registerThread("cdzThreadCustomThread", cdzThreadCustomThread, "充电调度线程", "schedule");
|
|
}
|
|
|
|
private void registerThread(String key, CustomThread<?> thread, String desc, String type) {
|
|
if (thread != null) {
|
|
threadMap.put(key, thread);
|
|
threadDescMap.put(key, desc);
|
|
threadTypeMap.put(key, type);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 开始线程 读取
|
|
*/
|
|
public void startAllThread() {
|
|
plcSsjReadCustomThread.getThread().start();
|
|
plcSrgvReadCustomThread1.getThread().start();
|
|
plcSrgvReadCustomThread2.getThread().start();
|
|
plcTsjReadCustomThread.getThread().start();
|
|
monitoringCustomThread.getThread().start();
|
|
//充电桩读取线程
|
|
plcCdzjReadCustomThread.getThread().start();
|
|
isRun = true;
|
|
}
|
|
|
|
/**
|
|
* 开启线程2 调度
|
|
*/
|
|
public void startAllThread2() {
|
|
ssjThreadCustomThread.thread.start();
|
|
tsjThreadCustomThread.thread.start();
|
|
sRgvThreadCustomThread.thread.start();
|
|
cdzThreadCustomThread.thread.start();
|
|
isRun2 = true;
|
|
}
|
|
|
|
/**
|
|
* 停止线程读取
|
|
*/
|
|
public void stopAllThread() {
|
|
plcSsjReadCustomThread.runnable.isRun = false;
|
|
plcSrgvReadCustomThread1.runnable.isRun = false;
|
|
plcSrgvReadCustomThread2.runnable.isRun = false;
|
|
plcTsjReadCustomThread.runnable.isRun = false;
|
|
monitoringCustomThread.runnable.isRun = false;
|
|
plcReadInit();
|
|
isRun = false;
|
|
}
|
|
|
|
/**
|
|
* 停止线程调度
|
|
*/
|
|
public void stopAllThread2() {
|
|
ssjThreadCustomThread.runnable.isRun = false;
|
|
tsjThreadCustomThread.runnable.isRun = false;
|
|
sRgvThreadCustomThread.runnable.isRun = false;
|
|
scheduleInit();
|
|
isRun2 = false;
|
|
}
|
|
|
|
/**
|
|
* 获取调度状态
|
|
*/
|
|
public HashMap<String, Boolean> getScheduleStatus() {
|
|
HashMap<String, Boolean> map = new HashMap<>();
|
|
map.put("isRun", isRun);
|
|
map.put("isRun2", isRun2);
|
|
return map;
|
|
}
|
|
|
|
/**
|
|
* 获取所有受管线程状态
|
|
*/
|
|
public List<Map<String, Object>> getAllThreadStatus() {
|
|
List<Map<String, Object>> list = new ArrayList<>();
|
|
for (String key : threadDescMap.keySet()) {
|
|
CustomThread<?> ct = threadMap.get(key);
|
|
Map<String, Object> info = new HashMap<>();
|
|
info.put("key", key);
|
|
info.put("name", threadDescMap.get(key));
|
|
info.put("type", threadTypeMap.get(key));
|
|
boolean alive = false;
|
|
boolean isRun = false;
|
|
if (ct != null && ct.getRunnable() != null) {
|
|
try {
|
|
Field field = ct.getRunnable().getClass().getField("isRun");
|
|
isRun = field.getBoolean(ct.getRunnable());
|
|
} catch (Exception e) {
|
|
log.error("获取线程[{}]isRun状态异常", key);
|
|
}
|
|
}
|
|
info.put("isRun", isRun);
|
|
if (ct != null && ct.getThread() != null) {
|
|
alive = ct.getThread().isAlive();
|
|
}
|
|
info.put("alive", alive);
|
|
list.add(info);
|
|
}
|
|
return list;
|
|
}
|
|
|
|
/**
|
|
* 启动指定线程
|
|
*/
|
|
public synchronized void startThread(String key) {
|
|
CustomThread<?> ct = threadMap.get(key);
|
|
if (ct == null) {
|
|
throw new RuntimeException("未知线程: " + key);
|
|
}
|
|
if (ct.getThread() != null && ct.getThread().isAlive()) {
|
|
log.info("线程 {} 已经在运行中", key);
|
|
return;
|
|
}
|
|
|
|
// 设置Runnable isRun = true
|
|
setRunnableIsRun(ct.getRunnable(), true);
|
|
|
|
// 创建新线程
|
|
Thread newThread = new Thread((Runnable) ct.getRunnable(), key);
|
|
ct.setThread(newThread);
|
|
newThread.start();
|
|
log.info("线程 {} 已启动", key);
|
|
}
|
|
|
|
/**
|
|
* 停止指定线程
|
|
*/
|
|
public synchronized void stopThread(String key) {
|
|
CustomThread<?> ct = threadMap.get(key);
|
|
if (ct == null) {
|
|
throw new RuntimeException("未知线程: " + key);
|
|
}
|
|
// 设置Runnable isRun = false
|
|
setRunnableIsRun(ct.getRunnable(), false);
|
|
log.info("线程 {} 停止指令已下发", key);
|
|
}
|
|
|
|
private void setRunnableIsRun(Object runnable, boolean isRun) {
|
|
try {
|
|
Field field = runnable.getClass().getField("isRun"); // 使用getField获取public字段
|
|
field.setBoolean(runnable, isRun);
|
|
} catch (NoSuchFieldException e) {
|
|
// 尝试查找父类或非public字段? 目前都是public
|
|
log.error("无法找到isRun字段: {}", runnable.getClass().getName());
|
|
} catch (IllegalAccessException e) {
|
|
log.error("无法访问isRun字段: {}", runnable.getClass().getName());
|
|
}
|
|
}
|
|
|
|
|
|
}
|