进程和线程A。进程是程序在操作系统中的一次执行过程，系统进行资源分配和调度的一个独立单位。B。线程是进程的一个执行实体，是CPU调度和分派的基本单位，它是比进程更小的能独立运行的基本单位。C。一个进程可以创建和撤销多个线程；同一进程中的多个线程之间可以并发执行。 
并发和并行
并发：多线程程序在一个核的cpu上运行
并行：多线程程序在多个核的cpu上运行
举例。。一个妈给一个碗给多个小孩喂饭，，是并发
一个妈给每个小孩一人一个碗，就是并行
并发 并行
协程和线程
协程：独立的栈空间，共享堆空间，调度由用户自己控制，本质上有点类似于用户级协程，这些用户级线程的调度也是自己实现的。
线程：一个线程上可以跑多个协程，协程是轻量级的线程。 例子
package mainimport ("fmt""time" )func test() {var i intfor {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 mainimport ("fmt""runtime" )func main() {num := runtime.NumCPU()runtime.GOMAXPROCS(num)fmt.Println(num) }
并发计算
package mainimport ("fmt""sync""time" )var (m = make(map[int]uint64)lock sync.Mutex )type task struct {n int }func calc(t *task) {var sum uint64sum = 1for i := 1; i < t.n; i++ {sum *= uint64(i)}fmt.Println(t.n, sum)lock.Lock()m[t.n] = sumlock.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\n", 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 mainimport "fmt"type student struct {name string }func main() {var stuChan chan *studentstuChan = make(chan *student, 10)stu := student{name: "stu001"}stuChan <- &stuvar stu01 interface{}stu01 = <-stuChanvar stu02 *studentstu02, ok := stu01.(*student)if !ok {fmt.Println("can not convert")return}fmt.Println(stu02) }
goroutine与channel
package mainimport ("fmt""time" )//起一个读的协程 func write(ch chan int) {for i := 0; i < 1000; i++ {ch <- i} }func read(ch chan int) {for {var b intb = <-chfmt.Println(b)} }func main() {intChan := make(chan int, 10)go write(intChan)go read(intChan)time.Sleep(10 * time.Second) }
读，取，字符串
package mainimport ("fmt""time" )func sendData(ch chan string) {ch <- "Washington"ch <- "Tripoli"ch <- "London"ch <- "Beijing"ch <- "Tokio" }func getData(ch chan string) {var input stringfor {input = <-chfmt.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 mainimport ("fmt""sync""time" )var (m = make(map[int]uint64)lock sync.Mutex )type task struct {n int }func calc(t *task) {var sum uint64sum = 1for i := 1; i < t.n; i++ {sum *= uint64(i)}fmt.Println(t.n, sum)lock.Lock()m[t.n] = sumlock.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\n", k, v)}lock.Unlock() }
package mainimport ("fmt" )func calc(taskChan chan int, resChan chan int, exitChan chan bool) {for v := range taskChan {flag := truefor i := 2; i < v; i++ {if v%i == 0 {flag = falsebreak}}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++ {<-exitChanfmt.Println("wait goroute", i, "exited")}close(resultChan)}()for v := range resultChan {fmt.Println(v)}}
package mainimport "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 := <-chif !ok {break}fmt.Println(v)}var a struct{}exitChan <- a } func main() {var ch chan intch = make(chan int, 10)exitChan := make(chan struct{}, 2)go send(ch, exitChan)go recv(ch, exitChan)var total = 0for _ = range exitChan {total++if total == 2 {break}} }
检测管道是否关闭
package mainimport "fmt"func main() {var ch chan intch = make(chan int, 10)for i := 0; i < 10; i++ {ch <- i}close(ch)for {var b intb, 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 mainimport "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 := <-chif !ok {break}fmt.Println(v)}var a struct{}exitChan <- a }func main() {var ch chan intch = make(chan int, 10) //初始化chanexitChan := make(chan struct{}, 2)go send(ch, exitChan)go recv(ch, exitChan)var total = 0for _ = range exitChan {total++if total == 2 {break}}}
不阻塞
package mainimport "fmt" import "time"func main() {var ch chan intch = make(chan int, 10)ch2 := make(chan int, 10)go func() {var i intfor {ch <- itime.Sleep(time.Second)ch2 <- i * itime.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)}} }