基礎(chǔ)概念
什么是進(jìn)程？
進(jìn)程：一個(gè)正在運(yùn)行的程序一般是一個(gè)進(jìn)程，一個(gè)進(jìn)程可以包含多個(gè)線程
每個(gè)進(jìn)程都有自己的獨(dú)立的地址空間（內(nèi)存空間），簡單的理解一個(gè)運(yùn)行程序?yàn)橐粋€(gè)進(jìn)程
什么是線程
線程：一條有序的CPU命令的集合體
線程有就緒，阻塞和運(yùn)行三個(gè)基本狀態(tài)
什么是多線程
多線程：多條有序的CPU命令的結(jié)合體
備注：一個(gè)CPU在同一時(shí)刻只能執(zhí)行一個(gè)CPU命令
假設(shè)只有一個(gè)CPU，能不能進(jìn)行多線程編程
3個(gè)線程: 并發(fā)編程
線程1: 5個(gè)命令
線程2：3個(gè)命令
線程3: 8個(gè)命令
3個(gè)線程: 串行編程
線程1: 5個(gè)命令
線程2：3個(gè)命令
線程3: 8個(gè)命令
線程1，線程2，線程3，假設(shè)在只有一個(gè)CPU的情況，編發(fā)編程，
需要通過上下文切換，實(shí)現(xiàn)上下文的切片，時(shí)間片的輪轉(zhuǎn)分配
1.并發(fā)編程：
多個(gè)線程，會(huì)有時(shí)間片的分配問題，多個(gè)線程之間會(huì)不斷的切換
2.串行編程：
根據(jù)添加線程的順序，按照順序一一執(zhí)行
多線程編程優(yōu)點(diǎn)：分線程可以處理耗時(shí)操作，不會(huì)出現(xiàn)主線程阻塞
多線程編程缺點(diǎn)：資源競爭，內(nèi)存消耗，死鎖
有如下兩種
1.物理CPU：
2.邏輯CPU
一個(gè)物理CPU可以虛擬出多個(gè)邏輯CPU
8核同一時(shí)刻可以同時(shí)最多執(zhí)行8個(gè)CPU命令
Go 運(yùn)用線程編寫程序
golang的線程是一種并發(fā)機(jī)制
定義好函數(shù)，要實(shí)現(xiàn)這個(gè)函數(shù)的并發(fā)執(zhí)行，只要用go關(guān)鍵字就可以了
package main
import "fmt"
// runtime：有兩種形式，一種是一條直線，另一種是一個(gè)圈
// 當(dāng)前demo中，仍然是一條直線
// 當(dāng)程序執(zhí)行到主函數(shù)中最后一個(gè)}時(shí)，整個(gè)程序結(jié)束
//下面程序創(chuàng)建了兩個(gè)分線程，加上主線程，一共三個(gè)線程
func main() {
fmt.Println("foo() start")
go foo() //在方法名前面+關(guān)鍵字go 就開 啟了一個(gè)分線程 把foo()的執(zhí)行放到分線程里面
fmt.Println("foo() end")
fmt.Println("bar() start")
go bar() //把bar()的執(zhí)行放到分線程里面
fmt.Println("bar() end")
f1()//此方法在主線程
}
func f1() {
for k := 0; k < 10; k++ {
fmt.Println("k:", k)
}
}
func foo() {
for i := 0; i < 100; i++ {
fmt.Println("i:", i)
}
}
func bar() {
for j := 0; j < 200; j++ {
fmt.Println("j:", j)
}
}
輸出為：
foo() start
foo() end
bar() start
bar() end
k: 0
k: 1
k: 2
k: 3
k: 4
k: 5
k: 6
k: 7
k: 8
k: 9
這里，我們就可以看到子線程的死亡有兩種途徑，一種是子線程運(yùn)行結(jié)束，另一種是主線程運(yùn)行結(jié)束runtime主動(dòng)殺死子線程。
下面runtime是跑一個(gè)圈：
package main
import (
"fmt"
"sync"
"time"
)
/*
const (
Nanosecond Duration = 1
Microsecond = 1000 * Nanosecond
Millisecond = 1000 * Microsecond
Second = 1000 * Millisecond
Minute = 60 * Second
Hour = 60 * Minute
)
*/
var wg sync.WaitGroup//創(chuàng)建一個(gè)wg 對象，類型為sync.WaitGroup（sync里面的一個(gè)WaitGroup類）
func main() {
wg.Add(2) ////添加線程的個(gè)數(shù)并統(tǒng)計(jì)管理所添加的線程
go foo() //線程1
go bar() //線程2
wg.Wait() //讓主線程等待分線程執(zhí)行，只有隊(duì)列中counter計(jì)數(shù)器的值變?yōu)?時(shí)，主線程才會(huì)運(yùn)行wg.Wait()這條命令后面的命令直至結(jié)束,從而讓runtime編程跑了一圈
}
func foo() {
for i := 0; i < 45; i++ {
fmt.Println("Foo:", i)
time.Sleep(3 * time.Second) //耗時(shí)3秒
}
wg.Done()//這行命令是添加在分線程所要運(yùn)行的地方里的，當(dāng)分線程中的任務(wù)處理完成后，counter計(jì)數(shù)器減1
}
func bar() {
for i := 0; i < 45; i++ {
fmt.Println("Bar:", i)
time.Sleep(20 * time.Second) //耗時(shí)20秒
}
wg.Done()
}
設(shè)置機(jī)器能夠參與執(zhí)行的CPU的個(gè)數(shù),
速度會(huì)提升很多
package main
import (
"fmt"
"runtime"
"sync"
"time"
)
var wg sync.WaitGroup
// runtime.NumCPU() 邏輯CPU個(gè)數(shù)
// runtime.GOMAXPROCS設(shè)置機(jī)器能夠參與執(zhí)行的CPU的個(gè)數(shù)
// init()方法會(huì)在main函數(shù)之前執(zhí)行
func init() {
fmt.Println("init()")
fmt.Println(runtime.NumCPU())
runtime.GOMAXPROCS(runtime.NumCPU())
}
func main() {
fmt.Println("main() start()")
wg.Add(2)
go foo()
go bar()
wg.Wait()
}
func foo() {
for i := 0; i < 45; i++ {
fmt.Println("Foo:", i)
time.Sleep(3 * time.Millisecond)
}
wg.Done()
}
func bar() {
for i := 0; i < 45; i++ {
fmt.Println("Bar:", i)
time.Sleep(20 * time.Millisecond)
}
wg.Done()
}
下面這個(gè)程序
主線程會(huì)等待子線程執(zhí)行完，整個(gè)程序才結(jié)束
package main
import (
"fmt"
"sync"
)
// go run -race main.go 檢查是否有資源競爭
// vs
// go run main.go
var wg sync.WaitGroup
func main() {
wg.Add(1)
a := 1
go func() { //子線程
a = 2
fmt.Println("a is func ", a)
wg.Done()
}()
a = 3
fmt.Println("a is main", a)
wg.Wait()
}
輸出為
a is main 3
a is func 2
下面這個(gè)demo，兩個(gè)子線程執(zhí)行完，程序才結(jié)束，
但哪個(gè)線程先執(zhí)行不固定
package main
import (
"fmt"
"sync"
)
var ticktCount int = 100
var wg sync.WaitGroup //一個(gè)隊(duì)列
func main() {
wg.Add(2)
go f1()
go f2()
wg.Wait()
}
func f1() {
ticktCount--
fmt.Println("f1", ticktCount)
wg.Done()
}
func f2() {
ticktCount = ticktCount - 2
fmt.Println("f2", ticktCount)
wg.Done()
}
輸出為：
f2 98
f1 97
若代碼有資源競爭，對數(shù)據(jù)加鎖
對子線程進(jìn)行管理
package main
import (
"fmt"
"math/rand"
"sync"
"time"
)
// 當(dāng)前代碼有資源競爭，我們需要對數(shù)據(jù)加鎖
// go run -race main.go 競爭檢測
// vs
// go run main.go
var wg sync.WaitGroup //管理線程的隊(duì)列
var counter int //全局變量
var mutex sync.Mutex // 互斥
func main() {
wg.Add(2) //wg中的counter為2
go incrementor("Foo:") //新增一個(gè)線程
go incrementor("Bar:") //新增一個(gè)線程
wg.Wait() //主線程需要等待子線程的任務(wù)執(zhí)行完成，才會(huì)繼續(xù)往下執(zhí)行
fmt.Println("Final Counter:", counter)
}
func incrementor(s string) {
// 不設(shè)置時(shí)間種子的話，每次生成的rand值相同
rand.Seed(time.Now().UnixNano())
for i := 0; i < 20; i++ {
// rand.Intn 生成隨機(jī)數(shù)
time.Sleep(time.Duration(rand.Intn(3)) * time.Millisecond)
mutex.Lock() //上鎖，上鎖后，被鎖定的內(nèi)容不會(huì)被兩個(gè)或者多個(gè)線程同時(shí)競爭
counter++
fmt.Println(s, i, "Counter:", counter)
mutex.Unlock() //解鎖
}
wg.Done()
}
除上面方法外
還可以使用原子操作
package main
import (
"fmt"
"math/rand"
"sync"
"sync/atomic" //原子操作
"time"
)
// 當(dāng)前代碼有資源競爭，我們需要對數(shù)據(jù)加鎖
// go run -race main.go 競爭檢測
// vs
// go run main.go
var wg sync.WaitGroup //管理線程的隊(duì)列
var counter int64 //全局變量
// counter
// 原子操作：同一時(shí)刻同一條數(shù)據(jù)只能被一個(gè)線程擁有
// 非原子操作：同一時(shí)刻，同一條數(shù)據(jù)可能同時(shí)會(huì)被多個(gè)線程競爭
func main() {
wg.Add(2) //wg中的counter為2
go incrementor("Foo:") //新增一個(gè)線程
go incrementor("Bar:") //新增一個(gè)線程
wg.Wait() //主線程需要等待子線程的任務(wù)執(zhí)行完成，才會(huì)繼續(xù)往下執(zhí)行
fmt.Println("Final Counter:", counter)
}
func incrementor(s string) {
// 不設(shè)置時(shí)間種子的話，每次生成的rand值相同
rand.Seed(time.Now().UnixNano())
for i := 0; i < 20; i++ {
// rand.Intn 生成隨機(jī)數(shù)
time.Sleep(time.Duration(rand.Intn(3)) * time.Millisecond)
//原子操作，下面的代碼是讓counter+1
atomic.AddInt64(&counter, 1)
fmt.Println(s, i, "Counter:", counter)
}
wg.Done()
}
