进程和线程
A。进程是程序在操作系统中的一次执行过程，系统进行资源分配和调度的一个独立单位。
B。线程是进程的一个执行实体，是CPU调度和分派的基本单位，它是比进程更小的能独立运行的基本单位。
C。一个进程可以创建和撤销多个线程；同一进程中的多个线程之间可以并发执行。
并发和并行
并发：多线程程序在一个核的cpu上运行
并行：多线程程序在多个核的cpu上运行
举例。。一个妈给一个碗给多个小孩喂饭，，是并发
一个妈给每个小孩一人一个碗，就是并行
并发 并行
协程和线程
协程：独立的栈空间，共享堆空间，调度由用户自己控制，本质上有点类似于用户级协程，这些用户级线程的调度也是自己实现的。
线程：一个线程上可以跑多个协程，协程是轻量级的线程。
例子
package main import ( "fmt" "time" ) func test() { var i int for { fmt.Println(i) time.Sleep(time.Second) i++ } } func main() { go test() //起一个协程执行test（） for { fmt.Println("i : runnging in main") time.Sleep(time.Second ) } }
-
--
设置Golang运行的cpu核数。
1.8版本以上，默认跑多个核
package main import ( "fmt" "runtime" ) func main() { num := runtime.NumCPU() runtime.GOMAXPROCS(num) fmt.Println(num) }
并发计算
package main import ( "fmt" "sync" "time" ) var ( m = make(map[int]uint64) lock sync.Mutex ) type task struct { n int } func calc(t *task) { var sum uint64 sum = 1 for i := 1; i < t.n; i++ { sum *= uint64(i) } fmt.Println(t.n, sum) lock.Lock() m[t.n] = sum lock.Unlock() } func main() { for i := 0; i < 16; i++ { t := &task{n: i} go calc(t)//并发执行，谁快谁先出 } time.Sleep(10 * time.Second) //lock.Lock() //for k, v := range m { // fmt.Printf("%d!=%v ", k, v) //} //lock.Unlock() }
Channel
channel概念
a。类似unix中的管道(pipe)
b.先进先出
c。线程安全，多个goroutine同时访问，不需要枷锁
d。channel是有类型的，一个整数的channel只能存整数
channel声明
var name chan string var age chan int var mapchan chan map[string]string var test chan student var test1 chan *student
channel初始化
使用make进行初始化 var test chan int test = make(chan int,10) var test chan string test=make(chan string,10)
channel基本操作
从channel读取数据
var testChan chan int testChan = make(chan int, 10) var a int a = <-testChan
-从channel写入数据
var testChan chan int testChan = make(chan int, 10) var a int = 10 testChan <- a
第一个例子
package main import "fmt" type student struct { name string } func main() { var stuChan chan *student stuChan = make(chan *student, 10) stu := student{name: "stu001"} stuChan <- &stu var stu01 interface{} stu01 = <-stuChan var stu02 *student stu02, ok := stu01.(*student) if !ok { fmt.Println("can not convert") return } fmt.Println(stu02) }
goroutine与channel
package main import ( "fmt" "time" ) //起一个读的协程 func write(ch chan int) { for i := 0; i < 1000; i++ { ch <- i } } func read(ch chan int) { for { var b int b = <-ch fmt.Println(b) } } func main() { intChan := make(chan int, 10) go write(intChan) go read(intChan) time.Sleep(10 * time.Second) }
读，取，字符串
package main import ( "fmt" "time" ) func sendData(ch chan string) { ch <- "Washington" ch <- "Tripoli" ch <- "London" ch <- "Beijing" ch <- "Tokio" } func getData(ch chan string) { var input string for { input = <-ch fmt.Println(input) } } func main() { ch := make(chan string) go sendData(ch) go getData(ch) time.Sleep(3 * time.Second) }
Channel缓冲区
只能放一个元素的testChan var testChan chan int testChan = make(chan int) var a int a = <-testChan
-
testChan是带缓冲区的chan，一次可以放10个元素
var testChan chan int testChan = make(chan int, 10) var a int = 10 testChan <- a
-
package main import ( "fmt" "sync" "time" ) var ( m = make(map[int]uint64) lock sync.Mutex ) type task struct { n int } func calc(t *task) { var sum uint64 sum = 1 for i := 1; i < t.n; i++ { sum *= uint64(i) } fmt.Println(t.n, sum) lock.Lock() m[t.n] = sum lock.Unlock() } func main() { for i := 0; i < 16; i++ { t := &task{n: i} go calc(t) } time.Sleep(10 * time.Second) lock.Lock() for k, v := range m { fmt.Printf("%d!=%v ", k, v) } lock.Unlock() }
package main import ( "fmt" ) func calc(taskChan chan int, resChan chan int, exitChan chan bool) { for v := range taskChan { flag := true for i := 2; i < v; i++ { if v%i == 0 { flag = false break } } if flag { resChan <- v } } fmt.Println("exit") exitChan <- true } func main() { intChan := make(chan int, 1000) resultChan := make(chan int, 1000) exitChan := make(chan bool, 8) go func() { for i := 0; i < 10000; i++ { intChan <- i } close(intChan) }() for i := 0; i < 8; i++ { go calc(intChan, resultChan, exitChan) } //等待所有计算的goroutine全部退出 go func() { for i := 0; i < 8; i++ { <-exitChan fmt.Println("wait goroute", i, "exited") } close(resultChan) }() for v := range resultChan { fmt.Println(v) } }
package main import "fmt" func send(ch chan int, exitChan chan struct{}) { for i := 0; i < 10; i++ { ch <- i } close(ch) var a struct{} exitChan <- a } func recv(ch chan int, exitChan chan struct{}) { for { v, ok := <-ch if !ok { break } fmt.Println(v) } var a struct{} exitChan <- a } func main() { var ch chan int ch = make(chan int, 10) exitChan := make(chan struct{}, 2) go send(ch, exitChan) go recv(ch, exitChan) var total = 0 for _ = range exitChan { total++ if total == 2 { break } } }
检测管道是否关闭
package main import "fmt" func main() { var ch chan int ch = make(chan int, 10) for i := 0; i < 10; i++ { ch <- i } close(ch) for { var b int b, ok := <-ch //检测管道是否关闭 if ok == false { fmt.Println("chan is close") break } fmt.Println(b) } }
如何关闭chan
1. 使用内置函数close进行关闭，chan关闭之后，for range遍历chan中 已经存在的元素后结束 2. 使用内置函数close进行关闭，chan关闭之后，没有使用for range的写法 需要使用，v, ok := <- ch进行判断chan是否关闭
chan的只读和只写
只读的声明 Var 变量的名字 <-chan int Var readChan <- chan int 只写的声明 Var 变量的名字 chan<- int Var writeChan chan<- int
package main import "fmt" //只写chan func send(ch chan<- int, exitChan chan struct{}) { for i := 0; i < 10; i++ { ch <- i } close(ch) var a struct{} exitChan <- a } //只读chan func recv(ch <-chan int, exitChan chan struct{}) { for { v, ok := <-ch if !ok { break } fmt.Println(v) } var a struct{} exitChan <- a } func main() { var ch chan int ch = make(chan int, 10) //初始化chan exitChan := make(chan struct{}, 2) go send(ch, exitChan) go recv(ch, exitChan) var total = 0 for _ = range exitChan { total++ if total == 2 { break } } }
不阻塞
package main import "fmt" import "time" func main() { var ch chan int ch = make(chan int, 10) ch2 := make(chan int, 10) go func() { var i int for { ch <- i time.Sleep(time.Second) ch2 <- i * i time.Sleep(time.Second) i++ } }() for { select { case v := <-ch: fmt.Println(v) case v := <-ch2: fmt.Println(v) case <-time.After(time.Second): fmt.Println("get data timeout") time.Sleep(time.Second) } } }