DELL
2025-02-11 cec8535c3bd288d555f0252e240fc19998febb84
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
133
134
package com.dev.lock.alarm;
 
import java.util.Calendar;
import java.util.Date;
 
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
 
import com.dev.lock.alarm.data.ElectLock_AlarmData;
import com.dev.lock.data.ElectLock_Array;
import com.dev.lock.data.ElectLock_ComBase;
import com.dev.lock.data.ElectLock_Inf;
import com.dev.lock.data.ElectLock_RecordState;
import com.sql.MysqlConnPool;
 
 
public class ElectLock_Alarm_Thread extends Thread{
    private static final int Max_TimeOut = 180;                        //最大超时时间3分钟-通信故障
    private static final int MaxRecordAlmTimeLong = 365*5;            //历史告警表最大保留天数
    
    
    private MysqlConnPool pool;
    private ElectLock_Array ElLock_Array;
    private Logger logger;
    
    public ElectLock_Alarm_Thread(MysqlConnPool pool,ElectLock_Array ElLock_Array) {
        this.pool = pool;
        this.ElLock_Array = ElLock_Array;
        this.logger = LogManager.getLogger(this);
    }
    
    @Override
    public void run() {
        logger.info("ElectLock_Alarm_Thread Start ...");
        for(int n =0 ; n < 60 ; n++) {
            try {
                //sleep(1000);
                ElectLock_Alarm_Thread_SQL.updateProcess_ProcessTime(pool);    
            } catch (Exception e) {
                logger.error(e.toString(),e);
            }
        }
        Date now = null;
        Date lastDelete = new Date(0);
        while(true) {
            try {
                sleep(150);
                
                ElectLock_Alarm_Thread_SQL.changeTempAlmToRealAlm(pool);
                
                sleep(50);
                now = new Date();
                for(int n = 0;n<ElLock_Array.getIteamCount();n++) {
                    if(n%10 == 0) {
                        sleep(10);
                        //更新运行线程
                        ElectLock_Alarm_Thread_SQL.updateProcess_ProcessTime(pool);        
                    }
                    ElectLock_Inf inf = ElLock_Array.getIteam(n);
                    ElectLock_Alarm_Thread_SQL.queryElectLockState(pool,inf);
                    boolean isTimeOut = false;
                    if(Math.abs(inf.lockState.getNow_time().getTime()-inf.lockState.getRecord_time().getTime())/1000 > Max_TimeOut) {
                        //通信超时
                        isTimeOut = true;
                    }
                    //构造通信故障告警
                    makeLockAlarm(inf.getLock_id(),isTimeOut,ElectLock_ComBase.ALM_CommErr_ID,ElectLock_ComBase.ALM_Source_PlatForm);
                    
                    if(inf.lockState.getLock_state() == ElectLock_RecordState.Lock_State_Open) {
                        //检测锁具开启,将开锁失败告警记录移动到历史告警表
                        makeLockAlarm(inf.getLock_id(),false,ElectLock_ComBase.ALM_OpenLockErr_ID,ElectLock_ComBase.ALM_Source_DeFault);
                    }
                }
                
                long deleteTimeLong = (now.getTime()-lastDelete.getTime())/(24*60*60*1000);
                //System.out.println("deleteTimeLong:"+deleteTimeLong);
                if(deleteTimeLong > 1) {
                    //每天检测一次删除历史告警数据                    
                    Date deldate = getDateBefore(now, MaxRecordAlmTimeLong);
                    //检测历史告警记录,删除3年前的告警记录分表
                    ElectLock_Alarm_Thread_SQL.delLockAlarmData(pool, deldate);                
                    
                    lastDelete = now;
                }
            } catch (Exception e) {
                logger.error(e.toString(),e);
            }
        }
    }
 
    
    /**
     * 检测当前告警
     * @param lock_id
     * @param isTimeOut
     * @param almCommerrId
     * @param almSourcePlatform
     */
    private void makeLockAlarm(int lock_id, boolean isTimeOut, int almId, int almSource) {
        if(isTimeOut) {
            //告警状态-触发
            ElectLock_AlarmData almData = ElectLock_Alarm_Thread_SQL.queryElectLockAlarmByAlmId(pool,lock_id,almId);
            if(null == almData) {
                //当前告警不存在时,插入当前告警
                ElectLock_Alarm_Thread_SQL.insertElectLockAlarm(pool, lock_id, almId, almSource);
            }else {
                //已存在当前告警
            }
        }else {
            //告警状态-消失
            ElectLock_AlarmData almData = ElectLock_Alarm_Thread_SQL.queryElectLockAlarmByAlmId(pool,lock_id,almId);
            if(null != almData) {
                //将实时告警记录移动到历史告警表中
                ElectLock_Alarm_Thread_SQL.changeRealAlmToHisAlm(pool, almData);
            }
        }
    }
    
    
 
    /**
     *     获取指定时间之前指定天数的时间
     * @param d      指定时间
     * @param day    指定天数
     * @return
     */
    public static Date getDateBefore(Date d,int day){
        Calendar now =Calendar.getInstance();
        now.setTime(d);
        now.set(Calendar.DATE,now.get(Calendar.DATE)-day);
        return now.getTime();
    }
    
}