1 package main
2
3 import (
4 "fmt"
5 "runtime"
6 "strconv"
7 "sync"
8 "time"
9 )
10
11 // sync包中的WaitGroup实现了一个类似任务队列的结构，你可以向队列中加入任务，
12 // 任务完成后就把任务从队列中移除，如果队列中的任务没有全部完成，队列就会触发阻塞以阻止程序继续运行
13 var wg sync.WaitGroup // 实现goroutine的同步
14 var lock sync.Mutex // 互斥锁
15 var rwlock sync.RWMutex // 读写互斥锁
16
17 // 1. 启动单个 goroutine
18 func hello() {
19 fmt.Println("Hello!")
20 }
21
22 func f1() {
23 go hello()
24 fmt.Println("Hello Goroutine Down!")
25 time.Sleep(time.Second)
26 /*
27 // 注意顺序
28 Hello Goroutine Down!
29 Hello!
30 */
31 }
32
33 // 2. 启动多个 goroutine
34 func hello1(i int) {
35 defer wg.Done() // goroutine结束就登记-1
36 fmt.Println("Hello1 Goroutine: ", i)
37 }
38
39 func f2() {
40 for i := 0; i < 10; i++ {
41 wg.Add(1) // 启动一个goroutine就登记+1
42 go hello1(i)
43 /*
44 Hello1 Goroutine: 0
45 Hello1 Goroutine: 9
46 Hello1 Goroutine: 4
47 Hello1 Goroutine: 2
48 Hello1 Goroutine: 5
49 Hello1 Goroutine: 6
50 Hello1 Goroutine: 1
51 Hello1 Goroutine: 8
52 Hello1 Goroutine: 7
53 Hello1 Goroutine: 3
54 */
55 }
56 wg.Wait() // 等待所有登记的goroutine都结束
57 }
58
59 // 3. GOMAXPROCS
60 /*
61 Go运行时的调度器使用GOMAXPROCS参数来确定需要使用多少个OS线程来同时执行Go代码。默认值是机器上的CPU核心数。
62 一个操作系统线程对应用户态多个goroutine。
63 go程序可以同时使用多个操作系统线程。
64 goroutine和OS线程是多对多的关系，即m:n。
65 */
66
67 func a() {
68 for i := 1; i < 10; i++ {
69 fmt.Println("A:", i)
70 }
71 }
72
73 func b() {
74 for i := 1; i < 10; i++ {
75 fmt.Println("B:", i)
76 }
77 }
78
79 func f3() {
80 v := runtime.GOMAXPROCS(2) // 设置 1 顺序输出; 2 随机交替输出
81 fmt.Println("默认机器核心数是：", v)
82 go a()
83 go b()
84 time.Sleep(time.Second)
85 }
86
87 // 4. 通道 Go 提倡通过通信共享内存而不是通过共享内存而实现通信
88 // var ch chan int
89 // make(chan 元素类型, [缓冲大小])
90
91 // 无缓冲区通道，同步通道
92 func syncChannel(c chan int) {
93 ret := <-c
94 fmt.Println("通道取出值：", ret)
95 }
96
97 func f4() {
98 ch := make(chan int)
99 go syncChannel(ch) // 启用goroutine从通道接收值
100 ch <- 10
101 fmt.Println("通道发送值成功!")
102 }
103
104 // 5 有缓冲区的通道
105 func f5() {
106 ch := make(chan int, 2) // 创建一个容量位2的 有缓冲区通道
107 ch <- 10
108 fmt.Printf("ch 的长度：%d,ch 的容量：%d\n", len(ch), cap(ch)) // ch 的长度：1,ch 的容量：2
109 }
110
111 // 6. 从通道循环取值
112 func f6() {
113 ch1 := make(chan int)
114 ch2 := make(chan int)
115
116 // 给 ch2 赋值
117 go func() {
118 for i := 0; i < 3; i++ {
119 ch1 <- i
120 }
121 close(ch1)
122 }()
123
124 go func() {
125 // 从通道取值的第一种方法
126 for {
127 i, ok := <-ch1
128 if !ok { // 判断通道是否为空
129 break
130 }
131 ch2 <- i * i
132 }
133 close(ch2)
134 }()
135
136 // 通道 ch3 关闭会退出 for range 循环
137 for i := range ch2 {
138 // 从通道取值的第二种方法
139 fmt.Println("从ch2中取出值：", i)
140 // 从ch2中取出值： 0
141 // 从ch2中取出值： 1
142 // 从ch2中取出值： 4
143 }
144 }
145
146 // 7. 单向通道
147 func outCh(out <-chan int) {
148 for i := range out {
149 println("输出通道, 值：", i)
150 }
151 }
152
153 func inCh(in chan<- int) {
154 for i := 0; i < 3; i++ {
155 in <- i
156 }
157 close(in)
158 }
159
160 func square(in chan<- int, out <-chan int) {
161 for i := range out {
162 in <- i * i
163 }
164 close(in)
165 }
166
167 func f7() {
168 ch1 := make(chan int)
169 ch2 := make(chan int)
170
171 go inCh(ch1) // 限制通道在函数中只能接收
172 go square(ch2, ch1) // 限制一个可发送、一个可接收的通道
173 outCh(ch2) // 限制通道在函数中只能发送
174 }
175
176 // 8. 线程池 worker pool
177 func worker(id int, jobs <-chan int, results chan<- int) {
178 for j := range jobs {
179 fmt.Printf("Worder %d start job %d\n", id, j)
180 time.Sleep(time.Second)
181 fmt.Printf("Worder %d end job %d\n", id, j)
182 results <- 2 * j
183 }
184 }
185
186 func f8() {
187 jobs := make(chan int, 100)
188 results := make(chan int, 100)
189 // 开启三个 goroutine
190 for w := 1; w < 4; w++ {
191 go worker(w, jobs, results)
192 }
193 // 5个任务
194 for j := 1; j < 6; j++ {
195 jobs <- j
196 }
197 close(jobs)
198 // 打印结果
199 for a := 1; a < 6; a++ {
200 <-results
201 }
202 // worker:3 start job:1
203 // worker:1 start job:2
204 // worker:2 start job:3
205 // worker:1 end job:2
206 // worker:1 start job:4
207 // worker:3 end job:1
208 // worker:3 start job:5
209 // worker:2 end job:3
210 // worker:1 end job:4
211 // worker:3 end job:5
212 }
213
214 // 9. select 多路复用
215 // 可处理一个或多个channel的发送/接收操作。
216 // 如果多个case同时满足，select会随机选择一个。
217 // 对于没有case的select{}会一直等待，可用于阻塞main函数。
218 func f9() {
219 ch := make(chan int, 1)
220 for i := 0; i < 10; i++ {
221 select {
222 // ch 能取出值
223 case x := <-ch:
224 fmt.Printf("%d\t", x) // 0 2 4 6 8
225 // 值能放进 ch
226 case ch <- i:
227 }
228 }
229 }
230
231 // 10. 互斥锁
232 // 不加锁的情况
233 func add(x *int64) {
234 for i := 0; i < 5000; i++ {
235 *x += 1
236 }
237 wg.Done()
238 }
239
240 // 加锁的情况
241 func add1(x *int64) {
242 for i := 0; i < 5000; i++ {
243 lock.Lock()
244 *x += 1
245 lock.Unlock()
246 }
247 wg.Done()
248 }
249
250 func f10() {
251 var x int64
252 wg.Add(2)
253 // go add(&x) // 不加锁
254 // go add(&x) // 不加锁
255 go add1(&x)
256 go add1(&x)
257 wg.Wait()
258 fmt.Println(x)
259 }
260
261 // 11. 读写互斥锁
262 // 读写锁非常适合读多写少的场景，如果读和写的操作差别不大，读写锁的优势就发挥不出来
263
264 func write(x *int64) {
265 // lock.Lock()
266 rwlock.Lock() // 写锁
267 *x += 1
268 rwlock.Unlock()
269 // lock.Unlock()
270 wg.Done()
271 }
272
273 func read() {
274 // lock.Lock()
275 rwlock.RLock()
276 time.Sleep(time.Millisecond) // 假设读操作耗时1毫秒
277 rwlock.RUnlock()
278 // lock.Unlock()
279 wg.Done()
280 }
281
282 func f11() {
283 var x int64
284 start := time.Now()
285
286 for i := 0; i < 500; i++ {
287 wg.Add(1)
288 go write(&x)
289 }
290
291 for j := 0; j < 5000; j++ {
292 wg.Add(1)
293 go read()
294 }
295
296 wg.Wait()
297 fmt.Println(x, time.Since(start))
298 // lock: 500 6.0364704s
299 // rwlock: 500 10.9918ms
300 }
301
302 // 12. sync.map
303 func f12() {
304 var m = sync.Map{}
305 for i := 0; i < 100; i++ {
306 wg.Add(1)
307 go func(n int) {
308 key := strconv.Itoa(n)
309 m.Store(key, n) // map 存
310 value, _ := m.Load(key) // map 取
311 fmt.Printf("n=:%d,k=:%v,v:=%v\n", n, key, value)
312 wg.Done()
313 }(i)
314 }
315 wg.Wait()
316 }
317
318 func main() {
319 f12()
320 }