#

luxiaotao1123

2024-11-09 87fda255732e4709e923f5b4c1e6b401e20c6002

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
package com.zy.acs.manager.core;
 
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.zy.acs.framework.common.R;
import com.zy.acs.manager.manager.entity.Agv;
import com.zy.acs.manager.manager.enums.StatusType;
import com.zy.acs.manager.manager.service.AgvService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
 
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import java.util.Map;
import java.util.concurrent.*;
 
/**
 * Created by vincent on 11/9/2024
 */
@Slf4j
@Service
public class PatrolService {
 
    private static final int SCHEDULE_TIME_INTERVAL = 1;
    private static final Map<String, ScheduledFuture<?>> AGV_PATROL_MAP = new ConcurrentHashMap<>();
 
    private ScheduledExecutorService scheduler = null;
 
    @Autowired
    private AgvService agvService;
 
    public boolean isPatrolling(String agvNo) {
        ScheduledFuture<?> scheduledFuture = AGV_PATROL_MAP.get(agvNo);
        if (scheduledFuture == null) {
            return false;
        }
        return !scheduledFuture.isCancelled() && !scheduledFuture.isDone();
    }
 
    public R startupPatrol(String agvNo) {
        if (AGV_PATROL_MAP.containsKey(agvNo)) {
            return R.error("AGV " + agvNo + " 的跑库任务已经在运行中。");
        }
 
        Runnable patrolTask = () -> {
            try {
                executePatrolLogic(agvNo);
            } catch (Exception e) {
                log.error("执行AGV " + agvNo + " 跑库任务时发生异常: " + e.getMessage());
                e.printStackTrace();
            }
        };
 
        ScheduledFuture<?> scheduledFuture = scheduler.scheduleAtFixedRate(patrolTask, 0, SCHEDULE_TIME_INTERVAL, TimeUnit.SECONDS);
 
        AGV_PATROL_MAP.put(agvNo, scheduledFuture);
        log.info("已启动AGV " + agvNo + " 的跑库任务。");
        return R.ok();
    }
 
 
    public R shutdownPatrol(String agvNo) {
        ScheduledFuture<?> scheduledFuture = AGV_PATROL_MAP.get(agvNo);
        if (scheduledFuture == null) {
            return R.error("AGV " + agvNo + " 没有正在运行的跑库任务。");
        }
 
        boolean cancelled = scheduledFuture.cancel(true);
        if (cancelled) {
            AGV_PATROL_MAP.remove(agvNo);
            log.info("已停止AGV " + agvNo + " 的跑库任务。");
            return R.ok("已停止AGV " + agvNo + " 的跑库任务。");
        } else {
            log.error("未能成功停止AGV " + agvNo + " 的跑库任务。");
            return R.error("未能成功停止AGV " + agvNo + " 的跑库任务。");
        }
    }
 
    private void executePatrolLogic(String agvNo) {
        // TODO: 在这里实现具体的跑库业务逻辑
        log.info("执行AGV " + agvNo + " 的跑库任务。");
    }
 
    @PostConstruct
    public void init() {
        int count = agvService.count(new LambdaQueryWrapper<Agv>().eq(Agv::getStatus, StatusType.ENABLE.val));
        if (count > 0) {
            this.scheduler = Executors.newScheduledThreadPool(count);
        }
    }
 
    @PreDestroy
    public void destroy() throws InterruptedException {
        for (Map.Entry<String, ScheduledFuture<?>> entry : AGV_PATROL_MAP.entrySet()) {
            entry.getValue().cancel(true);
        }
        scheduler.shutdown();
        if (!scheduler.awaitTermination(5, TimeUnit.SECONDS)) {
            scheduler.shutdownNow();
        }
    }
 
}