Go语言之Goroutine与信道异常处理

func test() {
   fmt.Println("go go go")
}

func main() {
   fmt.Println("主线程开始")
    
   // go 关键字开启 Goroutine，一个 Goroutine只占2kb左右
   go test() // 一个 go 就是一个协程，多个就是多个协程，也可以for循环起多个协程
   go test()
    
   time.Sleep(1*time.Second)  // Go 语言中主线程不会等待Goroutine执行完成，要等待它结束需要自己处理
   fmt.Println("主线程结束")
}

// 输出：
主线程开始
go go go
go go go
主线程结束

func main() {
   // 1、定义 channel
   var c chan int

   // 2、管道的零值
   //———>空值为 nil 说明是引用类型，当做参数传递时，不需要取地址，改的就是原来的，需要初始化在使用
   fmt.Println(c)     // 输出：<nil>

   // 3、管道初始化
   c = make(chan int)
   go test(c)        // c 是引用类型直接传

   // 4、从信道中取值，信道默认不管放值还是取值，都是阻塞的
   count := <-c   // 阻塞
   fmt.Println(count)
   
   /*
   当程序执行 go test(c) 时就开了一个 Goroutine
   然后继续执行到 count := <-c 从信道取值，这时就阻塞住了
   它会等待 Goroutine 往信道中放值后才会取出值，才会继续执行 fmt.Println(count)
   */
}

func test(c chan int) {
   fmt.Println("GO GO GO")
   time.Sleep(1 * time.Second)
   // 5、往信道中放一个值，信道默认不管放值还是取值，都是阻塞的
   c <- 1 // 阻塞
}

// 输出：
<nil>
GO GO GO
1

func main() {  
    c := make(chan int)
    c <- 1
}

// 报错：应为没有其他 Goroutine 从 c 中取值

func WriteOnly(c chan<- int) {
   c <- 1
}

func main() {
   write := make(chan<- int)  // 只写信道
   go WriteOnly(write)
   fmt.Println(<-write)      // 报错   ——>只写信道往外取就报错
}

func WriteOnly(c chan<- int) {
   c <- 1
   // <-c       // 报错
}

func main() {
   write := make(chan int)    // 定义一个可读可写信道
   go WriteOnly(write)        // 传到函数中就成了只写信道，在Goroutine中只负责写，不能往外读
   fmt.Println(<-write)     // 主协程读
}

func producer(chnl chan int) {
   for i := 0; i < 10; i++ {
      chnl <- i   // i 放入信道
   }
   close(chnl)      // 关闭信道
}

func main() {
   ch := make(chan int)
   go producer(ch)
   // 循环获取信道内容
   for value := range ch {
      fmt.Println(value)
   }
}

/*
当 for 循环 range ch 的时候信道没有值，会阻塞等待 go producer(ch) 开起的 Goroutine 中放入值
当 Goroutine 中放入一个值，就会阻塞，那么 range ch 就会取出一个值，然后再次阻塞等待
直到 Goroutine 放入值完毕关闭信道，for 循环 range ch 也就结束循环了
*/

func main() {
   // 指定的数字就是缓冲大小
   var c chan int = make(chan int, 3) // 无缓冲信道数字是0
   c <- 1
   c <- 2
   c <- 3
   c <- 4     // 缓冲满了，死锁

   <-c
   <-c
   <-c
   <-c          // 取空了，死锁

   fmt.Println(len(c))       // 长度：目前放了多少
   fmt.Println(cap(c))       // 容量：可以最多放多少
}

func process1(i int, wg *sync.WaitGroup) {
   fmt.Println("started Goroutine ", i)
   time.Sleep(2 * time.Second)
   fmt.Printf("Goroutine %d endedn", i)
   // 3、一旦有一个完成，减一
   wg.Done()
}

func main() {
   var wg sync.WaitGroup    // 没有初始化，值类型，当做参数传递，需要取地址

   for i := 0; i < 10; i++ {
      wg.Add(1)      // 1、启动一个 Goroutine，add 加 1
      go process1(i, &wg)     // 2、把wg传过去，因为要改它并且它是值类型需要取地址传过去
   }

   wg.Wait()  // 4、一直阻塞在这，直到调用了10个 Done，计数器减到零
}

// 模拟去服务器去取值
func server(ch chan string) {
   time.Sleep(3 * time.Second)
   ch <- "from server"
}

func main() {
   output1 := make(chan string)
   output2 := make(chan string)
    
   // 开起两个协程执行 server
   go server(output1)
   go server(output2)

   select {
   case s1 := <-output1:  // 阻塞，谁先回来就执行谁
      fmt.Println(s1, "output1")
   case s2 := <-output2:  // 阻塞，谁先回来就执行谁
      fmt.Println(s2, "output2")
   }
}

var x = 0   //全局，各个 Goroutine 都可以拿到并且操作

func increment(wg *sync.WaitGroup) {
   x = x + 1
   wg.Done()
}

func main() {
   var w sync.WaitGroup
   for i := 0; i < 1000; i++ {
      w.Add(1)
      go increment(&w)
   }
   w.Wait()

   fmt.Println("最终的值：", x)
}

// 输出：理想情况下是1000，因为并发有安全的问题，所以数据乱了
最终的值： 978

var x = 0   //全局，各个 Goroutine 都可以拿到并且操作

func increment(wg *sync.WaitGroup, m *sync.Mutex) {
   m.Lock()    // 加锁
   x = x + 1 // 同一时间只能有一个 Goroutine 执行
   m.Unlock()  // 解锁
   wg.Done()
}
func main() {
   var w sync.WaitGroup
   var m sync.Mutex    // 因为是个值类型，函数传递需要传地址
   fmt.Println(m)     // 输出：{0 0} ——>值类型

   for i := 0; i < 1000; i++ {
      w.Add(1)
      go increment(&w, &m)
   }
   w.Wait()
   fmt.Println("最终的值：", x)
}

// 输出：
最终的值： 1000

var x = 0

func increment(wg *sync.WaitGroup, ch chan bool) {
   ch <- true   // 缓冲信道放满了，就会阻塞。
   x = x + 1
   <-ch         // 执行完了就取出
   wg.Done()
}
func main() {
   var w sync.WaitGroup
   ch := make(chan bool, 1)   // 定义了一个有缓存大小为1的信道
   for i := 0; i < 1000; i++ {
      w.Add(1)
      go increment(&w, ch)
   }

   w.Wait()
   fmt.Println("最终的值：", x)
}

// 输出：
最终的值：1000

func main() {
 defer fmt.Println("我最后执行")
 defer fmt.Println("我倒数第三执行")
 fmt.Println("我先执行")
    
 var a []int
 fmt.Println(a[10])   // 报错

 fmt.Println("后执行") // 不会执行了
}


// 输出：
我先执行
我倒数第三执行
我最后执行
panic: runtime error: index out of range [10] with length 0
panic：主动抛出异常

recover：恢复程序，继续执行

func f1() {
   fmt.Println("f1 f1")
}


func f2() {
   defer func() {        // 这个匿名函数永远会执行

      //如果没有错误，执行 recover 会返回 nil，如果有错误执行 recover 会返回错误信息
      if error := recover(); error != nil {
         // 表示出错了，打印一下错误信息，程序恢复了，继续执行
         fmt.Println(error)
      }
      fmt.Println("我永远会执行，不管是否出错")
   }()
    
   fmt.Println("f2 f2")
   panic("主动抛出错误")
}


func f3() {
   fmt.Println("f3 f3")
}


func main() {
   //捕获异常，处理异常，让程序继续运行
   f1()
   f2()
   f3()
}

try:
 可能会错误的代码
except Exception as e：
 print(e)
finally：
 无论是否出错，都会执行的代码

defer func() {
 if error:=recover();error!=nil{
  // 错误信息 error
  fmt.Println(error)
 }
    
 相当于finally，无论是否出错，都会执行的代码
    
}()

可能会错误的代码