1、靳总协议上行数据处理修改完善; 2、上行数据处理任务修改完善.

liurunyu

2024-06-28 4fe7ea4fbdc0c45f14d1d8de77e3424f826ba909

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
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
package com.dy.rtuMw.server.rtuData;
 
import java.util.ArrayList;
import java.util.List;
 
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
 
 
public class TaskPool {
 
    private static Logger log = LogManager.getLogger(TaskPool.class.getName()) ;
    
    private static List<TaskSurpport> tasks = new ArrayList<TaskSurpport>() ;
    
    private static TreeConfig taskTreeConf ;
    
    
    public static void setTaskTreeCofig(TreeConfig conf){
        taskTreeConf = conf ;
    }
    
    
    /**
     * 得到任务
     * 多线程环境下运行
     * @return
     */
    public static TaskSurpport popTask(){
        synchronized(tasks){
            TaskSurpport t = (tasks.size() > 0)?tasks.get(0):null ;
            if(t != null){
                tasks.remove(0) ;
            }else{
                try {
                    t = newTaskTree() ;
                } catch (Exception e) {
                    log.error(e.getMessage() == null?"实例化上行数据处理任务对象树失败！" : e.getMessage(), e);
                } finally {
                    if(t == null){
                        log.error("实例化上行数据处理任务对象失败！" );
                    }
                }
            }
 
            return t ;
        }
    }
    
    /**
     * 放回任务
     * 多线程环境下运行
     * 这里需要同步锁，因为上面方法中执行完tasks.get(0)且未执行tasks.remove(0)期间，本方法执行并且执行完，那么后期就会出乱子
     * @param t
     */
    public static void freeAndCleanTask(TaskSurpport t){
        synchronized(tasks) {
            if (t != null) {
                boolean find = false;
                for (TaskSurpport tin : tasks) {
                    if (tin == t) {
                        find = true;
                        break;
                    }
                }
                if (!find) {
                    t.cleanMeAndSubs();
                    tasks.add(0, t);
                }
            }
        }
    }
    
    /**
     * 实例化任务对象树
     * @return
     * @throws Exception
     */
    private static TaskSurpport newTaskTree() throws Exception{
        TaskSurpport t = null ;
        if(taskTreeConf != null){
            t = newTask(null, taskTreeConf.taskConf, taskTreeConf.subTreeConfs) ;
        }
        return t ;
    }
    
    private static TaskSurpport newTask(TaskSurpport root, TaskConfig taskConf, TreeConfig[] subTreeConfs) throws Exception{
        TaskSurpport t = null ;
        if(taskConf != null){
            t = instanceTask(taskConf.clazz) ;
            if(t != null){
                t.conf = taskConf ;
                t.root = root ;
                if(root == null){
                    root = t ;
                }
                newSubTask(root, t, subTreeConfs);
            }
        }
        return t ;
    }
    private static void newSubTask(TaskSurpport root, TaskSurpport parent, TreeConfig[] treeConfs)throws Exception{
        if(parent != null && treeConfs != null && treeConfs.length > 0){
            parent.subTasks = new TaskSurpport[treeConfs.length] ;
            for(int i = 0 ; i < treeConfs.length; i++){
                parent.subTasks[i] = newTask(root, treeConfs[i].taskConf, treeConfs[i].subTreeConfs) ;
            }
        }
    }
    private static TaskSurpport instanceTask(String clazz)throws Exception{
        Class<?> c = Class.forName(clazz);
        if (c == null) {
            throw new Exception("实例化上行数据处理任务对象树失败！任务类为" + clazz + "！");
        }else{
            return (TaskSurpport)c.getDeclaredConstructor().newInstance();
            //return (TaskSurpport)c.newInstance();
        }
    }
 
}