---

panlei

2019-07-09 90a1178e6aac8457a2821d9ffb15affc5dd13b73

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
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     // 赋值后就不变的初始值
    Data        AreaMap //
    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 _, timeEle := range TimeEleList {
                    if timeEle.N > 0 {
                        timeEle.N = timeEle.N - 1
                        logger.Info("-------------------------------------打印定时器元素当前值-----------------------------------------：",timeEle.N)
                    }
                }
            case stop := <-stopChan:
                if stop {
                    logger.Info("定时器结束")
                    return
                    //os.Exit(0)
                }
            }
        }
    }(ticker)
}
func StopTimeTicker() {
    stopChan <- true
    TimeTicker()
}
 
// 定时器单元  废弃版本
// func TimeTicker() chan bool {
//     logger.Info("执行了timeTicker")
//     ticker := time.NewTicker(1 * time.Second)
//     stopChan := make(chan bool)
//     go func(ticker *time.Ticker) {
//         defer ticker.Stop()
//         for {
//             select {
//             case <-ticker.C:
//                 //logger.Info("执行单元", "计数器集合2", TimeEleList)
//                 for k, timeEle := range TimeEleList {
//                     timeEle.n = timeEle.n - 1
//                     //logger.Info("遍历的数值", TimeEleList)
//                     if timeEle.n == 0 {
//                         // do something alarm
//                         alarm(k, timeEle)
//                     }
//                 }
//             case stop := <-stopChan:
//                 if stop {
//                     logger.Info("定时器结束")
//                     return
//                 }
//             }
//         }
//     }(ticker)
//     return stopChan
// }
 
// 结构体根据某字段排序
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 }