【Golang学习笔记】05

要点

goroutine

runtime.GOMAXPPROCS

Channel select

sync.mutex

init

多线程

goroutine

go + func

func task01()  {
for ;; {
fmt.Println("task01")
}
}

func task02()  {
for ;; {
fmt.Println("task02")
}
}

func main() {
go task01()
go task02()
time.Sleep(1 * time.Minute)
}
/*
task1和task2并发执行
……
task01
task01
task02
task01
task02
task01
task01
……
*/

goroutine的匿名写法

//匿名goroutine
go func() {
fmt.Printf("\n Task3Start TimeNow: ",time.Now())
time.Sleep(2 * time.Second)
fmt.Printf("\n Task3End TimeNow: ",time.Now())
}()

sync.WaitGroup

阻塞线程，可以阻塞住主线程使其等待子线程结束

wg.Add(1)，wg.Done(wg.Add(-1))，wg.Wait()当wg不为0时阻塞住线程

func task1()  {
fmt.Printf("\n Task1Start TimeNow: ",time.Now())
time.Sleep(1 * time.Second)  // 睡眠一秒
fmt.Printf("\n Task1End TimeNow: ",time.Now())
wg.Done()
}

func task2()  {
fmt.Printf("\n Task2Start TimeNow: ",time.Now())
time.Sleep(2 * time.Second)
fmt.Printf("\n Task2End TimeNow: ",time.Now())
wg.Done()
}

func main()  {
wg.Add(3)
fmt.Printf("\n CurTime: ",time.Now())
go task1()
go task2()

//匿名goroutine
go func() {//task3
fmt.Printf("\n Task3Start TimeNow: ",time.Now())
time.Sleep(2 * time.Second)
fmt.Printf("\n Task3End TimeNow: ",time.Now())
wg.Done()
}()

wg.Wait()
fmt.Printf("\n End CurTime: ",time.Now())
}

/*
task1 + task2 + task的阻塞时间是 1 + 2 + 2 = 5s，在使用goroutine后只耗费了2s
CurTime: %!(EXTRA time.Time=2018-01-22 21:31:19.405001 +0800 CST m=+0.005000301)
Task3Start TimeNow: %!(EXTRA time.Time=2018-01-22 21:31:19.4210019 +0800 CST m=+0.021001201)
Task1Start TimeNow: %!(EXTRA time.Time=2018-01-22 21:31:19.4210019 +0800 CST m=+0.021001201)
Task2Start TimeNow: %!(EXTRA time.Time=2018-01-22 21:31:19.4210019 +0800 CST m=+0.021001201)
Task1End TimeNow: %!(EXTRA time.Time=2018-01-22 21:31:20.4210591 +0800 CST m=+1.021058401)
Task3End TimeNow: %!(EXTRA time.Time=2018-01-22 21:31:21.4211163 +0800 CST m=+2.021115601)
Task2End TimeNow: %!(EXTRA time.Time=2018-01-22 21:31:21.4211163 +0800 CST m=+2.021115601)
End CurTime: %!(EXTRA time.Time=2018-01-22 21:31:21.4211163 +0800 CST m=+2.021115601)
*/

runtime.GOMAXPROCS

设置当前goroutine可使用的cpu最大数量， runtime.NumCPU() 此机器的cpu数量

func count()  {
x := 0
for i := 0; i < math.MaxInt32 ; i++ {
x ++
}
//  fmt.Println(x)
}

func task1(n int)  {
for i := 0; i < n; i++ {
count()
}
}

func task2(n int)  {
var wg sync.WaitGroup
for i := 0; i < n; i++ {
wg.Add(1)
go func() {
count()
wg.Done()
}()
}
wg.Wait()
}

func main() {
n := 5
start := time.Now().Second()
task1(n)
fmt.Printf("单线程共耗费时间: %v 秒 \n", time.Now().Second() - start)

for i := 1; i <= runtime.NumCPU(); i ++ {
start := time.Now().Second()
runtime.GOMAXPROCS(i)  //设置goroutine可使用的最大cpu数量 runtime.NumCPU() 此机器的cpu数量
task2(n)
fmt.Printf("Cpu使用数量:%v, 共耗费时间: %v 秒 \n", i, time.Now().Second() - start)
}
}

/*
单线程共耗费时间: 4 秒
Cpu使用数量:1, 共耗费时间: 4 秒
Cpu使用数量:2, 共耗费时间: 2 秒
Cpu使用数量:3, 共耗费时间: 2 秒
Cpu使用数量:4, 共耗费时间: 1 秒
Cpu使用数量:5, 共耗费时间: 1 秒
Cpu使用数量:6, 共耗费时间: 1 秒
Cpu使用数量:7, 共耗费时间: 1 秒
Cpu使用数量:8, 共耗费时间: 1 秒
*/

通道channel 阻塞线程

func main() {
event := make(chan struct{})

go func() {
time.Sleep(3 * time.Second)
close(event)
}()

<- event
fmt.Println("End")
}
//当子线程close(event)后，程序才会结束

close()

func main() {
a,b := make(chan int), make(chan int, 5)        // 默认为0  先进先出
b <- 1
b <- 2
b <- 3
fmt.Printf("a.len = %v  a.cap = %v \n", len(a), cap(a))  // a.len = 0  a.cap = 0
fmt.Printf("b.len = %v  b.cap = %v \n", len(b), cap(b))  // b.len = 3  b.cap = 5

close(b)    //如果channel被关闭了，就不可以往里放值，但是可以取值，而且不会死锁
//b <- 4    panic: send on closed channel
<- b
<- b
q, ok := <- b
fmt.Println(q, ok) // 3 true
q, ok = <- b
fmt.Println(q, ok) // 0 false
}

单向channel

var b <-chan interface{} = make(chan interface{}, 5)        // 只能读
var c chan<- interface{} = make(chan interface{}, 5)        // 只能写

channel的遍历

func main() {
a := make(chan int, 3)
a <- 10
a <- 20
a <- 30
close(a) // 如果不加这个,循环的时候就会因为等待输出阻塞线程，导致死锁
for i := range a{
fmt.Println(i)
}
}

或

func main() {
lenth :=  len(a)
for i := 0; i < lenth; i++ {
fmt.Println(<-a)
}
}

定时器

func main() {
t := time.NewTicker(1 * time.Second)
for  {
select {
case <- t.C:
fmt.Println("End")
}
}
}

sync.Mutex

防止两个线程同时使用一个资源，需要对资源加锁

func main() {
var wg sync.WaitGroup
a := 1
b := 1
wg.Add(4)

var ml sync.Mutex
// 不加锁

go func() {
for i := 0; i < 5000; i++ {
b += 1
}
wg.Done()
}()
go func() {
for i := 0; i < 5000; i++ {
b += 1
}
wg.Done()
}()

// 加锁
go func() {
ml.Lock()
for i := 0; i < 5000; i++ {
a += 1
}
wg.Done()
ml.Unlock()
}()
go func() {
ml.Lock()
for i := 0; i < 5000; i++ {
a += 1
}
wg.Done()
ml.Unlock()
}()

wg.Wait()

fmt.Println("不加锁后计算的值",b)
fmt.Println("加锁后计算的值",a)
}

//不加锁后计算的值 6842
//加锁后计算的值 10001

init

package LessonOther
import "fmt"

//init函数执行优先级高于main,
// 且可以有多个,
// 不可以被调用,
// 拼写必须是init
// 被其他包引用时也会调用
func init() {
fmt.Println("init1")
}

func init() {
fmt.Println("init2")
}

func init() {
fmt.Println("init3")
}

func Get()  {
fmt.Println("LessonOther -> Other.go -> Get 被调用")
}

package main

import "fmt"
import "../LessonOther"

func main() {
LessonOther.Get()
fmt.Println("main")
}

/*
init1
init2
init3
LessonOther -> Other.go -> Get 被调用
main
*/