第十六章 Golang中goroutine和channel

// 在主线程（可以理解成进程）中，开启一个goroutine，该协程每秒输出 “hello，world”
// 在主线程中也每隔一秒输出“hello,golang”,输出10次后，退出程序
// 要求主线程和goroutine同时执行
//编写一个函数，每隔1秒输出 “hello，world”
func test(){
   for i := 1;i<=10;i++{
    fmt.Println("test() hello,world"+strconv.Itoa(i))
    time.Sleep(time.Second)
  }
}
func main(){
    go test() // 开启了一个协程
    for i:=1;i<=10;i++{
    fmt.Println(" main() hello,golang"+strconv.Itoa(i))
    time.Sleep(time.Second)
  }
}

package main
 import "fmt"
 import "runtime"
 
func main(){
  // 获取当前系统CPU的数量
  num := runtime.NumCPU()
  // 这里设置num-1的CPU运行go程序
  runtime.GOMAXPROCS(num)
  fmt.Println("num=",num)
}

package main
import (
  "fmt"
  "time"
  "sync"
)
// 需求：现在要计算 1-200的各个数的阶乘，并且把各个数的阶乘放入到map中
// 最后显示出来。要求使用goroutine完成
// 思路
// 1. 编写一个函数，来计算各个数的阶乘，并放入到map中
// 2. 我们启动的协程多个，统计的将结果放入到map中
// 3. map应该做出一个全局的
var (
  myMap = make(map[int]int,10)
  // 声明一个全局的互斥锁
  // lock 是一个全局的互斥锁
  //sync 是包：synchornized 同步
  // Mutex: 是互斥
  lock sync.Mutex
)
// test函数就是计算n！,让将这个结果放入到myMap
func test(n int){
  res := 1
  for i := 1;i<=n;i++{
    res *= i
  }
  // 这里我们将res放入到myMap
  // 加锁
  lock.Lock()
  myMap[n] = res  // concurrent map writes?
  // 解锁
  lock.Unlock()
}
func main(){
  // 我们这里开启多个协程完成这个任务[200个]
  for i := 1;i<=20;i++{
    go test(i)
  }
  
  // 休眠10秒钟【第二个问题】
  time.Sleep(time.Second * 10)
  lock.Lock()
  // 这里我们输出结果 变量这个结果
  for i,v := range myMap{
    fmt.Printf("map[%d]=%d\n",i,v)
  } 
  lock.Unlock()
}

package main
import (
  "fmt"
)
func main(){
  // 演示一下管道的使用
  // 1.创建一个可以存放3个int类型的管道
  var intChan chan int
  intChan = make(chan int,3)
  
  // 2.看看intChannel是什么
  fmt.Printf("intChan 的值=%v intChan本身的地址=%p\n",intChan,&intChan)
  
  // 3.向管道写入数据
  intChan<- 10
  num := 211
  intChan<- num
  
  // 注意点，当我们给管写入数据时，不能超过其容量
  intChan<- 50
  // intChan<- 98
  
  //4. 看看管道的长度和cap(容量)
  fmt.Printf("channel len=%v cap=%v \n",len(intChan),cap(intChan)) // 2,3
  
  // 5.从管道中读取数据
  var num2 int 
  num2 = <-intChan
  fmt.Println("num2=",num2)
  fmt.Printf("channel len=%v cap=%v \n",len(intChan),cap(intChan)) // 2,3
  
  // 6.在没有使用协程的情况下，如果我们的管道数据已经全部取出，再取就会报告 deadlock
  num3 := <-intChan
  num4 := <-intChan
  // num5 := <-intChan
  
  fmt.Println("num3=",num3,"num4=",num4)//,"num5=",num5)
}

package main
import (
  "fmt"
)
type Cat struct{
  Name string
  Age int
}
func main(){
  // 定义一个存放任意数据类型的管道  3个数据
  // var callChan chan interface{}
  allChan := make(chan interface{},3)
  
  allChan<- 10
  allChan<- "tom jack"
  cat := Cat{"小花猫",4}
  allChan<- cat
  
  // 我们希望获得到管道中的第三个元素，则先将前2个推出
  <-allChan
  <-allChan
  
  newCat := <-allChan // 从管道中取出的Cat是什么？
  
  fmt.Printf("newCat=%T,newCat=%v\n",newCat,newCat)
  // 下面的写法是错误的！编译不通过
  // fmt.Printf("newCat.Name=%v",newCat.Name)
  // 使用类型断言
  a := newCat.(Cat)
  fmt.Printf("newCat.Name=%v",a.Name)
}

package main
import (
  "fmt"
)
func main(){
  intChan := make(chan int,3)
  intChan<- 100
  intChan<- 200
  close(intChan) // close
  // 这是不能够再写入到channel
  // intChan<-300
  fmt.Println("okook~")
  // 当管道关闭后，读取数据是可以的
  n1 := <-intChan
  fmt.Println("n1=",n1)
  
  // 遍历管道
  intChan2 := make(chan int,100)
  for i := 0; i< 100;i++{
    intChan2<-i*2 // 放入100个数据到管道
  }
  
  // 遍历管道不能使用普通的for循环
  
  // 在遍历时，如果channel没有关闭，则会出现deadlock的错误
  // 在遍历时，如果channel已经关闭，则会正常遍历数据，遍历完后，就会退出遍历
  close(intChan2)
  for  v := range intChan2{
    fmt.Println("v=",v)
  }
  
}