基础概念
什么是进程？
进程：一个正在运行的程序一般是一个进程，一个进程可以包含多个线程
每个进程都有自己的独立的地址空间（内存空间），简单的理解一个运行程序为一个进程
什么是线程
线程：一条有序的CPU命令的集合体
线程有就绪，阻塞和运行三个基本状态
什么是多线程
多线程：多条有序的CPU命令的结合体
备注：一个CPU在同一时刻只能执行一个CPU命令
假设只有一个CPU，能不能进行多线程编程
3个线程: 并发编程
线程1: 5个命令
线程2：3个命令
线程3: 8个命令
3个线程: 串行编程
线程1: 5个命令
线程2：3个命令
线程3: 8个命令
线程1，线程2，线程3，假设在只有一个CPU的情况，编发编程，
需要通过上下文切换，实现上下文的切片，时间片的轮转分配
1.并发编程：
多个线程，会有时间片的分配问题，多个线程之间会不断的切换
2.串行编程：
根据添加线程的顺序，按照顺序一一执行
多线程编程优点：分线程可以处理耗时操作，不会出现主线程阻塞
多线程编程缺点：资源竞争，内存消耗，死锁
有如下两种
1.物理CPU：
2.逻辑CPU
一个物理CPU可以虚拟出多个逻辑CPU
8核同一时刻可以同时最多执行8个CPU命令
Go 运用线程编写程序
golang的线程是一种并发机制
定义好函数，要实现这个函数的并发执行，只要用go关键字就可以了
package main
import "fmt"
// runtime：有两种形式，一种是一条直线，另一种是一个圈
// 当前demo中，仍然是一条直线
// 当程序执行到主函数中最后一个}时，整个程序结束
//下面程序创建了两个分线程，加上主线程，一共三个线程
func main() {
fmt.Println("foo() start")
go foo() //在方法名前面+关键字go 就开 启了一个分线程 把foo()的执行放到分线程里面
fmt.Println("foo() end")
fmt.Println("bar() start")
go bar() //把bar()的执行放到分线程里面
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
这里，我们就可以看到子线程的死亡有两种途径，一种是子线程运行结束，另一种是主线程运行结束runtime主动杀死子线程。
下面runtime是跑一个圈：
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//创建一个wg 对象，类型为sync.WaitGroup（sync里面的一个WaitGroup类）
func main() {
wg.Add(2) ////添加线程的个数并统计管理所添加的线程
go foo() //线程1
go bar() //线程2
wg.Wait() //让主线程等待分线程执行，只有队列中counter计数器的值变为0时，主线程才会运行wg.Wait()这条命令后面的命令直至结束,从而让runtime编程跑了一圈
}
func foo() {
for i := 0; i < 45; i++ {
fmt.Println("Foo:", i)
time.Sleep(3 * time.Second) //耗时3秒
}
wg.Done()//这行命令是添加在分线程所要运行的地方里的，当分线程中的任务处理完成后，counter计数器减1
}
func bar() {
for i := 0; i < 45; i++ {
fmt.Println("Bar:", i)
time.Sleep(20 * time.Second) //耗时20秒
}
wg.Done()
}
设置机器能够参与执行的CPU的个数,
速度会提升很多
package main
import (
"fmt"
"runtime"
"sync"
"time"
)
var wg sync.WaitGroup
// runtime.NumCPU() 逻辑CPU个数
// runtime.GOMAXPROCS设置机器能够参与执行的CPU的个数
// init()方法会在main函数之前执行
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()
}
下面这个程序
主线程会等待子线程执行完，整个程序才结束
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
下面这个demo，两个子线程执行完，程序才结束，
但哪个线程先执行不固定
package main
import (
"fmt"
"sync"
)
var ticktCount int = 100
var wg sync.WaitGroup //一个队列
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
若代码有资源竞争，对数据加锁
对子线程进行管理
package main
import (
"fmt"
"math/rand"
"sync"
"time"
)
// 当前代码有资源竞争，我们需要对数据加锁
// go run -race main.go 竞争检测
// vs
// go run main.go
var wg sync.WaitGroup //管理线程的队列
var counter int //全局变量
var mutex sync.Mutex // 互斥
func main() {
wg.Add(2) //wg中的counter为2
go incrementor("Foo:") //新增一个线程
go incrementor("Bar:") //新增一个线程
wg.Wait() //主线程需要等待子线程的任务执行完成，才会继续往下执行
fmt.Println("Final Counter:", counter)
}
func incrementor(s string) {
// 不设置时间种子的话，每次生成的rand值相同
rand.Seed(time.Now().UnixNano())
for i := 0; i < 20; i++ {
// rand.Intn 生成随机数
time.Sleep(time.Duration(rand.Intn(3)) * time.Millisecond)
mutex.Lock() //上锁，上锁后，被锁定的内容不会被两个或者多个线程同时竞争
counter++
fmt.Println(s, i, "Counter:", counter)
mutex.Unlock() //解锁
}
wg.Done()
}
除上面方法外
还可以使用原子操作
package main
import (
"fmt"
"math/rand"
"sync"
"sync/atomic" //原子操作
"time"
)
// 当前代码有资源竞争，我们需要对数据加锁
// go run -race main.go 竞争检测
// vs
// go run main.go
var wg sync.WaitGroup //管理线程的队列
var counter int64 //全局变量
// counter
// 原子操作：同一时刻同一条数据只能被一个线程拥有
// 非原子操作：同一时刻，同一条数据可能同时会被多个线程竞争
func main() {
wg.Add(2) //wg中的counter为2
go incrementor("Foo:") //新增一个线程
go incrementor("Bar:") //新增一个线程
wg.Wait() //主线程需要等待子线程的任务执行完成，才会继续往下执行
fmt.Println("Final Counter:", counter)
}
func incrementor(s string) {
// 不设置时间种子的话，每次生成的rand值相同
rand.Seed(time.Now().UnixNano())
for i := 0; i < 20; i++ {
// rand.Intn 生成随机数
time.Sleep(time.Duration(rand.Intn(3)) * time.Millisecond)
//原子操作，下面的代码是让counter+1
atomic.AddInt64(&counter, 1)
fmt.Println(s, i, "Counter:", counter)
}
wg.Done()
}
网友评论