liurunyu
2024-09-30 e18c4a8ac170fea6e079047a27f72032c80eee67
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
121
122
123
124
125
126
127
128
129
130
131
132
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 Integer taskTotal = 0 ;
    
    private static TreeConfig taskTreeConf ;
    
    
    public static void setTaskTreeCofig(TreeConfig conf){
        taskTreeConf = conf ;
    }
 
    /**
     * 得到任务树实例总数
     * @return
     */
    public static Integer totalTasks() {
        return taskTotal ;
    }
    
    
    /**
     * 得到任务
     * 多线程环境下运行
     * @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("实例化上行数据处理任务对象失败!" );
                    }else{
                        taskTotal++ ;
                    }
                }
            }
 
            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();
        }
    }
 
}