1、准备工作
准备数据：
生成随机数并写入文件，之后在把数据读取出来
|
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
|
//新生成整数随机数，并存储在txt文件中，func NewIntRandm(fileName string, number, maxrandm int) { filename := fileName file, err := os.Create(filename) if err != nil { return } r := rand.New(rand.NewSource(time.Now().UnixNano())) rans := make([]string, 0, number) for i := 0; i < number; i++ { rans = append(rans, strconv.Itoa(r.Intn(maxrandm))) } file.WriteString(strings.Join(rans, " ")) defer file.Close()}//把一串数组存入文件总func SavaRandmInt(fileName string, data []int) { if fileName == " " || len(data) == 0 { return } var file *os.File var openerr error file, openerr = os.Open(fileName) if openerr != nil { var newerr error file, newerr = os.Create(fileName) if newerr != nil { return } } rans := make([]string, 0, len(data)) for _, v := range data { rans = append(rans, strconv.Itoa(v)) } file.WriteString(strings.Join(rans, " ")) defer file.Close()} |
准备计时的程序：
|
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
|
package utilimport "time"type Stopwatch struct { start time.Time stop time.Time}func (s *Stopwatch) Start() { s.start = time.Now()}func (s *Stopwatch) Stop() { s.stop = time.Now()}//纳秒func (s Stopwatch) RuntimeNs() int { return s.stop.Nanosecond() - s.start.Nanosecond()}//微妙func (s Stopwatch) RuntimeUs() float64 { return (float64)(s.stop.Nanosecond()-s.start.Nanosecond()) / 1000.00}//毫秒func (s Stopwatch) RuntimeMs() float64 { return (float64)(s.stop.Nanosecond()-s.start.Nanosecond()) / 1000000.00}//秒func (s Stopwatch) RuntimeS() float64 { return (float64)(s.stop.Nanosecond()-s.start.Nanosecond()) / 10000000000.00} |
2、开始写排序
我模仿golang中的sort源码包中的写法，暴露了一个接口，把排序的实现都写在内部
|
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
|
package sort// package maintype Interface interface { //获取数据的长度 Len() int //判读索引为i和索引为j的值的大小，在实现的时候如果判断i>j 返回true，则为升序，反之为降序 Less(i, j int) bool //交换索引i，j的值 Swap(i, j int)}//冒泡排序func BubbleSort(data Interface) { n := data.Len() for index := 0; index < n; index++ { for j := index + 1; j < n; j++ { if data.Less(index, j) { data.Swap(index, j) } } }}//此方法比上面的冒泡算法快，因为我找最小元素是指记住下标，并没有每一次都做元素交换func SelectSort(data Interface) { n := data.Len() var min int for index := 0; index < n; index++ { min = index for j := index + 1; j < n; j++ { if data.Less(min, j) { min = j } } data.Swap(index, min) }}//插入排序func InsertSrot(data Interface) { count := data.Len() for index := 1; index < count; index++ { for j := index; j > 0 && data.Less(j, j-1); j-- { //j>0 做一个边界守护，不让下标小于0 data.Swap(j, j-1) } }}//希尔排序func ShellSort(data Interface) { N := data.Len() h := 1 for h < N/3 { h = 3*h + 1 } for h > 0 { for index := h; index < N; index++ { for j := index; j >= h && data.Less(j, j-h); j -= h { //j>0 做一个边界守护，不让下标小于0 data.Swap(j, j-h) } } h = h / 3 }}//快速排序func QuickSort(data Interface) { n := data.Len() low, row := 0, n-1 quickSort(data, low, row)}func quickSort(data Interface, low, row int) { if low < row { i, j, x, last := low, row, low, 0 //0就是使用第一个作为基准值,last这个变量时为了基准最后一次交换变量时出现在那次 for i < j { for i < j && data.Less(x, j) { //比x小的放在前面出现的坑中 j-- } if i < j { data.Swap(i, j) i++ x = j last = 1 } for i < j && data.Less(i, x) { //比x大的放在后面出现的坑中 i++ } if i < j { data.Swap(i, j) j-- x = i last = -1 } } if last == 1 { data.Swap(j, x) } else if last == -1 { data.Swap(i, x) } quickSort(data, low, i-1) quickSort(data, i+1, row) }}//通过控制Less方法来控制升序降序func HeapSort(data Interface) { makeHeap(data) n := data.Len() for i := n - 1; i >= 1; i-- { data.Swap(0, i) heapFixdown(data, 0, i) }}func makeHeap(data Interface) { n := data.Len() for i := (n - 1) >> 1; i >= 0; i-- { heapFixdown(data, i, n) }}func heapFixdown(data Interface, r, n int) { root := r //跟结点 for { leftChildIndex := root<<1 + 1 if leftChildIndex >= n { break } if leftChildIndex+1 < n && data.Less(leftChildIndex+1, leftChildIndex) { leftChildIndex++ } if data.Less(root, leftChildIndex) { return } data.Swap(leftChildIndex, root) root = leftChildIndex }} |
3、开始使用
|
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
|
//先实现这个排序接口type InSort []intfunc (is InSort) Len() int { return len(is)}//降序func (is InSort) Less(i, j int) bool { return is[i] > is[j]}func (is InSort) Swap(i, j int) { is[i], is[j] = is[j], is[i]}func main() { fileName := "randm.txt" // util.NewIntRandm(fileName, 1000000, 10000) //封装生成5000000个随机数字 fileUtil := util.FileUtil{} insort := InSort{} insort = fileUtil.ReaderAllInt(fileName) //读取生成的随机数 fmt.Println(insort.Len()) t := new(util.Stopwatch) //封装的计时间的方法 t.Start() // sort.HeapSort(insort) //开始排序，519.8732 ms sort.QuickSort(insort) //开始排序，7.0267 ms t.Stop() fmt.Println(t.RuntimeMs(), "ms") util.SavaRandmInt("result.txt", insort)} |
快排：10000数组 7.0267 ms，1000000数组 37.7612 ms
堆排序：10000数组 10.0039 ms，1000000数组 358.6429 ms
下面是我测试的一些数据：
|
1
2
3
4
5
6
7
|
HeapSort(insort) //堆排序 10000个数 4.0013 ms,100000个数 54.0659 ms,很稳定，500000个数 208.1511 ms 很稳定sort.QuickSort(insort, 0, len(insort)-1) //快速排序 10000个数 3.0017 ms,100000个数,33.0222 ms,很稳定，500000个数 150.1096 ms 很稳定,100000个数 94.0823 ms 很稳定sort.SelectSort(insort) //选择排序 10000个数 130.8017 ms,100000个数 时间很长sort.BubbleSort(insort) //冒泡排序 10000个数 203.5344ms ，100000个数 187.7438 mssort.InsertSrot(insort) // 插入排序 10000个数 858.6085 ms，100000个数,时间很长sort.ShellSort(insort) //希尔插入 10000个数 10.9876 ms，100000个数 46.0322 m ，就做这个范围，很稳定，500000个数 141.8833 ms，相对稳定sort.Sort(insort) //golang源码的排序 10000个数 6.0062 ms ，100000个数 19.9988 ms~89.0574 ms 不稳定,500000个数 358.2536 ms 稳定 |
补充：golang 定时任务方面time.Sleep和time.Tick的优劣对比
golang 写循环执行的定时任务，常见的有以下三种实现方式:
1、time.Sleep方法：
|
1
2
3
4
|
for { time.Sleep(time.Second) fmt.Println("我在定时执行任务")} |
2、time.Tick函数：
|
1
2
3
4
5
6
7
|
t1:=time.Tick(3*time.Second)for { select { case <-t1: fmt.Println("t1定时器") }} |
3、其中Tick定时任务，也可以先使用time.Ticker函数获取Ticker结构体，然后进行阻塞监听信息，这种方式可以手动选择停止定时任务，在停止任务时，减少对内存的浪费。
|
1
2
3
4
5
6
7
8
|
t:=time.NewTicker(time.Second)for { select { case <-t.C: fmt.Println("t1定时器") t.Stop() }} |
其中第二种和第三种可以归为同一类
这三种定时器的实现原理
一般来说，你在使用执行定时任务的时候，一般旁人会劝你不要使用time.Sleep完成定时任务，但是为什么不能使用Sleep函数完成定时任务呢，它和Tick函数比，有什么劣势呢？这就需要我们去探讨阅读一下源码，分析一下它们之间的优劣性。
首先，我们研究一下Tick函数，func Tick(d Duration) <-chan Time
调用Tick函数会返回一个时间类型的channel，如果对channel稍微有些了解的话，我们首先会想到，既然是返回一个channel，在调用Tick方法的过程中，必然创建了goroutine,该Goroutine负责发送数据，唤醒被阻塞的定时任务。我在阅读源码之后，确实发现函数中go出去了一个协程，处理定时任务。
按照当前的理解，使用一个tick,需要go出去一个协程，效率和对内存空间的占用肯定不能比sleep函数强。我们需要继续阅读源码才拿获取到真理。
简单的调用过程我就不陈述了，我在这介绍一下核心结构体和方法（删除了部分判断代码，解释我写在表格中）：
|
1
2
3
4
5
6
7
8
9
|
func (tb *timersBucket) addtimerLocked(t *timer) { t.i = len(tb.t) //计算timersBucket中，当前定时任务的长度 tb.t = append(tb.t, t)// 将当前定时任务加入timersBucket siftupTimer(tb.t, t.i) //维护一个timer结构体的最小堆（四叉树），排序关键字为执行时间，即该定时任务下一次执行的时间 if !tb.created { tb.created = true go timerproc(tb)// 如果还没有创建过管理定时任务的协程，则创建一个，执行通知管理timer的协程，最核心代码 }} |
timersBucket，顾名思义，时间任务桶，是外界不可见的全局变量。每当有新的timer定时器任务时，会将timer加入到timersBucket中的timer切片。
timerBucket结构体如下：
|
1
2
3
4
|
type timersBucket struct { lock mutex //添加新定时任务时需要加锁（冲突点在于维护堆） t []*timer //timer切片，构造方式为四叉树最小堆} |
func timerproc(tb *timersBucket) 详细介绍
可以称之为定时任务处理器，所有的定时任务都会加入timersBucket，然后在该函数中等待被处理。等待被处理的timer，根据when字段（任务执行的时间，int类型，纳秒级别）构成一个最小堆，每次处理完成堆顶的某个timer时，会给它的when字段加上定时任务循环间隔时间（即Tick(d Duration) 中的d参数），然后重新维护堆，保证when最小的timer在堆顶。当堆中没有可以处理的timer(有timer,但是还不到执行时间)，需要计算当前时间和堆顶中timer的任务执行时间差值delta，定时任务处理器沉睡delta段时间，等待被调度器唤醒。核心代码如下（注释写在每行代码的后面，删除一些判断代码以及不利于阅读的非核心代码）：
|
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
|
func timerproc(tb *timersBucket) { for { lock(&tb.lock) //加锁 now := nanotime() //当前时间的纳秒值 delta := int64(-1) //最近要执行的timer和当前时间的差值 for { if len(tb.t) == 0 { delta = -1 break }//当前无可执行timer,直接跳出该循环 t := tb.t[0] delta = t.when - now //取when组小的的timer，计算于当前时间的差值 if delta > 0 { break }// delta大于0，说明还未到发送channel时间，需要跳出循环去睡眠delta时间 if t.period > 0 { // leave in heap but adjust next time to fire t.when += t.period * (1 + -delta/t.period)// 计算该timer下次执行任务的时间 siftdownTimer(tb.t, 0) //调整堆 } else { // remove from heap，如果没有设定下次执行时间，则将该timer从堆中移除（time.after和time.sleep函数即是只执行一次定时任务） last := len(tb.t) - 1 if last > 0 { tb.t[0] = tb.t[last] tb.t[0].i = 0 } tb.t[last] = nil tb.t = tb.t[:last] if last > 0 { siftdownTimer(tb.t, 0) } t.i = -1 // mark as removed } f := t.f arg := t.arg seq := t.seq unlock(&tb.lock)//解锁 f(arg, seq) //在channel中发送time结构体,唤醒阻塞的协程 lock(&tb.lock) } if delta < 0 { // No timers left - put goroutine to sleep. goparkunlock(&tb.lock, "timer goroutine (idle)", traceEvGoBlock, 1) continue }// delta小于0说明当前无定时任务，直接进行阻塞进行睡眠 tb.sleeping = true tb.sleepUntil = now + delta unlock(&tb.lock) notetsleepg(&tb.waitnote, delta) //睡眠delta时间，唤醒之后就可以执行在堆顶的定时任务了 }} |
至此，time.Tick函数涉及到的主要功能就讲解结束了，总结一下就是启动定时任务时，会创建一个唯一协程，处理timer,所有的timer都在该协程中处理。
然后，我们再阅读一下sleep的源码实现，核心源码如下：
|
1
2
3
4
5
6
7
8
|
//go:linkname timeSleep time.Sleepfunc timeSleep(ns int64) { *t = timer{} //创建一个定时任务 t.when = nanotime() + ns //计算定时任务的执行时间点 t.f = goroutineReady //执行方法 tb.addtimerLocked(t) //加入timer堆，并在timer定时任务执行协程中等待被执行 goparkunlock(&tb.lock, "sleep", traceEvGoSleep, 2) //睡眠，等待定时任务协程通知唤醒} |
读了sleep的核心代码之后，是不是突然发现和Tick函数的内容很类似，都创建了timer,并加入了定时任务处理协程。神奇之处就在于，实际上这两个函数产生的timer都放入了同一个timer堆，都在定时任务处理协程中等待被处理。
优劣性对比，使用建议
现在我们知道了，Tick，Sleep，包括time.After函数，都使用的timer结构体，都会被放在同一个协程中统一处理，这样看起来使用Tick，Sleep并没有什么区别。
实际上是有区别的，Sleep是使用睡眠完成定时任务，需要被调度唤醒。Tick函数是使用channel阻塞当前协程，完成定时任务的执行。当前并不清楚golang 阻塞和睡眠对资源的消耗会有什么区别，这方面不能给出建议。
但是使用channel阻塞协程完成定时任务比较灵活，可以结合select设置超时时间以及默认执行方法，而且可以设置timer的主动关闭，以及不需要每次都生成一个timer(这方面节省系统内存，垃圾收回也需要时间)。
所以，建议使用time.Tick完成定时任务。
以上为个人经验，希望能给大家一个参考，也希望大家多多支持服务器之家。如有错误或未考虑完全的地方，望不吝赐教。
原文链接：https://blog.csdn.net/Mrs_len/article/details/54094390
