---

panlei

2019-07-13 17a0463d1336f820e929e6d7afa2dd475d80c8e4

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
package ruleserver
 
import (
    "fmt"
    "ruleprocess/logger"
    "time"
)
 
var stopChan = make(chan bool)
 
// 计数器map 独立任务的键是任务id拼接区域id 联动任务的键是groupid（能不能都用groupId?）
var TimeEleList = make(map[string]*TimeElement)
 
// 定时器元素
type TimeElement struct {
    N            int      // 按时间依次递减的当前值
    InitN        int      // 赋值后就不变的初始值
    BufferFlag     int      // 缓冲容错位 连续帧false才为false
    AlarmFlag     bool      // 报警标志位 定时器开启后第一次报警时会被置为true 往后再来报警也不会插进ES
    CacheSdkData SdkDatas // 定时器的缓存数据 持续时间类的开启定时器时要缓存一帧
    GroupId      string   // 联动规则需要记录下此时的规则组id
    RuleResults  []*RuleResult
}
type RuleResult struct {
    // 每个摄像机一个结构体
    CameraId    string // 摄像机id
    Sort        int32  // 摄像机在规则组中序号
    Result      string // 摄像机过滤数据得出的结果
    RuleWithPre string // 摄像机之间的连接符
}
 
func TimeTicker() {
    logger.Info("定时器执行了")
    fmt.Println("定时器执行了")
    ticker := time.NewTicker(1 * time.Second)
    go func(ticker *time.Ticker) {
        defer ticker.Stop()
        for {
            select {
            case <-ticker.C:
                logger.Info("定时器执行单元", time.Now().Unix())
                fmt.Println("定时器执行单元", time.Now().Unix())
                // 每秒钟计数器池子里所有的计数器元素都减一，减到0的是该报警的
                for k, timeEle := range TimeEleList {
                    if timeEle.N > 0 {
                        timeEle.N = timeEle.N - 1
                        logger.Error("-------------------------------------打印定时器元素当前值-----------------------------------------：", timeEle.N)
                    }
                    if timeEle.GroupId != "" && timeEle.N == 0{
                        // 说明是联动任务的时间窗口 到点儿了该销毁了,再来了再创建
                        delete(TimeEleList,k)
                    }
                }
            case stop := <-stopChan:
                if stop {
                    logger.Info("定时器结束")
                    return
                    //os.Exit(0)
                }
            }
        }
    }(ticker)
}
func StopTimeTicker() {
    stopChan <- true
    TimeTicker()
}
 
 
// 结构体根据某字段排序
type SubList []*RuleResult
 
func (p SubList) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
func (p SubList) Len() int           { return len(p) }
func (p SubList) Less(i, j int) bool { return p[i].Sort < p[j].Sort }
 
// 结构体根据某字段排序
type resultList []*LittleRuleResult
 
func (p resultList) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
func (p resultList) Len() int           { return len(p) }
func (p resultList) Less(i, j int) bool { return p[i].Sort < p[j].Sort }