Go开发[八]goroutine和channel

小说:让别人晓得我总生活在表层作者:陵邓平更新时间:2019-03-21字数:65252

“既然是虎哥的兄弟,今天这事就算了吧。不过我不希望再看到,他们做这种下三滥的事情,尤其是威胁利诱我们这些进城的农民工兄弟们。”王小民语气不善的道。

琅琊榜为什么那么火?

但是去年的换届,韩松却突然空降至此,其中深意,明眼人一看就明白,这是高层对杜家人掌控凤鸣市不满意了,要动动手了。
所以,艾薇儿王妃戴上了女王首饰要是不想照镜子,那么除非是东方不败!

而且风魂记得,三百多年前的那天夜里,他给这两只小狐狸传授道法时……这丫头分明是睡着了。

进程和线程

进程是程序在操作系统中的一次执行过程,系统进行资源分配和调度的一个独立单位。

线程是进程的一个执行实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位。

一个进程可以创建和撤销多个线程;同一个进程中的多个线程之间可以并发执行.

并发和并行

多线程程序在一个核的cpu上运行,就是并发

多线程程序在多个核的cpu上运行,就是并行

协程和线程

协程:独立的栈空间,共享堆空间,调度由用户自己控制,本质上有点类似于用户级线程,这些用户级线程的调度也是自己实现的

线程:一个线程上可以跑多个协程,协程是轻量级的线程。

goroutine调度模型

简单的例子

package main

import "fmt"
import "time"

func test() {
   var i int
   for {
      fmt.Println(i)
      time.Sleep(time.Second*5)
      i++
   }
}

func main() {
   go test()
   for {
      fmt.Println("i" running in main")
      time.Sleep(time.Second)
   }
}

设置golang运行的cpu核数

go1.8版本以上默认设置了

package main

import (
    "fmt"
    "runtime"
)

func main() {
    num := runtime.NumCPU()
    runtime.GOMAXPROCS(num)
    fmt.Println(num)
}

不同goroutine之间通讯

全局变量和锁同步

package main

import (
   "fmt"
   "time"
   "sync"
)

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<20;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只能存放整数

var 变量名 chan 类型

var test chan int

var test chan string

var test chan map[string]string

var test chan stu

var test chan *stu

channel初始化

使用make进行初始化,比如:

var test chan int

test = make(chan int, 10)

var test chan string

test = make(chan string, 10)

从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

goroutine和channel相结合

package main

import (
   "fmt"
   "time"
)

func write(ch chan int) {
   for i := 0; i < 100; i++ {
      ch <- i
      fmt.Println("put data:", i)
   }
}

func read(ch chan int) {
   for {
      var b int
      b = <-ch
      fmt.Println(b)
      time.Sleep(time.Second)
   }
}

func main() {
   intChan := make(chan int, 10) //testChan是带缓冲区的chan,一次可以放10个元素
   go write(intChan)
   go read(intChan)//不读的话会引发阻塞
   time.Sleep(10 * time.Second)
}

chan之间的同步

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"
)
//计算1000以内的素数
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, 100)
   resultChan := make(chan int, 100)
   exitChan := make(chan bool, 8)

   go func() {
      for i := 0; i < 1000; 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)
      _ = v
   }
}

chan的关闭

1.使用内置函数close进行关闭,chan关闭之后,for range遍历chan中已经存在的元素后结束

2.使用内置函数close进行关闭,chan关闭之后,没有使用for range的写法需要使用,v, ok := <- ch进行判断chan是否关闭

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) //谨防死循环
   }
}

for range遍历chan

package main

import "fmt"

func main() {
   var ch chan int
   ch = make(chan int, 1000)
   for i := 0; i < 1000; i++ {
      ch <- i
   }

   close(ch)
   for v := range ch {
      fmt.Println(v)
   }
}

chan的只读和只写

a. 只读chan的声明

Var 变量的名字 <-chan int
Var readChan <- chan int

b. 只写chan的声明

Var 变量的名字 chan<- int
Var writeChan chan<- int

对chan进行select操作

select {
     case u := <- ch1:
     case e := <- ch2:
     default:   
  }

下面是死锁了,阻塞了

package main

import "fmt"

func main()  {
   var ch chan int
   ch = make(chan int,10)
   for i :=0;i<10;i++{
      ch <- i
   }
   for {
      var b int
      b = <-ch
      fmt.Println(b)
   }
}

select解决阻塞

//@Time  : 2018/2/1 22:14
//@Author: ningxin
package main

import (
   "fmt"
   "time"
)

func main()  {
   var ch chan int
   ch = make(chan int,10)
   for i :=0;i<10;i++{
      ch <- i
   }
   for {
      select{
      case v:= <-ch:
         fmt.Println(v)
      default:
         fmt.Println("get data timeout")
         time.Sleep(time.Second)
      }
   }
}

定时器的使用

package main

import (
    "fmt"
    "time"
)
func queryDb(ch chan int) {

    time.Sleep(time.Second)
    ch <- 100
}
func main() {
    ch := make(chan int)
    go queryDb(ch)
    t := time.NewTicker(time.Second)

    select {
    case v := <-ch:
        fmt.Println("result", v)
    case <-t.C:
        fmt.Println("timeout")
    }
}

超时控制

package main

import (
   "fmt"
   "runtime"
   "time"
)

func main() {
   num := runtime.NumCPU()
   runtime.GOMAXPROCS(num - 1)
   for i := 0; i < 16; i++ {
      go func() {
         for {
            t := time.NewTicker(time.Second)
            select {
            case <-t.C:
               fmt.Println("timeout")
            }
            t.Stop()
         }
      }()
   }

   time.Sleep(time.Second * 100)
}

goroutine中使用recover

应用场景,如果某个goroutine panic了,而且这个goroutine里面没有捕获(recover),那么整个进程就会挂掉。所以,好的习惯是每当go产生一个goroutine,就需要写下recover

package main

import (
   "fmt"
   "runtime"
   "time"
)

func test() {
   defer func() {
      if err := recover(); err != nil {
         fmt.Println("panic:", err)
      }
   }()
   var m map[string]int
   m["stu"] = 100
}

func calc() {
   for {
      fmt.Println("i"m calc")
      time.Sleep(time.Second)
   }
}

func main() {
   num := runtime.NumCPU()
   runtime.GOMAXPROCS(num - 1)
   go test()
   for i := 0; i < 2; i++ {
      go calc()
   }
   time.Sleep(time.Second * 10000)
}

编辑:王建

发布:2019-03-21 01:48:46

当前文章:http://leetaemin.cn/8boqm0whxd.html

公鸭嗓,不成熟,飞机场,周迅到底有啥好? 所有偷过的懒,都会变成打脸的巴掌 妈妈要重视,宝宝打呼噜,不是睡得香! 谢谢你的好意,可我不需要 精神和物质哪个更重要? 漫谈儿童的不适应行为及治疗 小学新生 入学前要做好哪些方面准备? 未来婆婆会不会成为扼杀感情的主要原因?

77085 99208 56850 42669 70648 8359621666 34680 51320

我要说两句: (0人参与)

发布