go：接口、并发与协程、信道、缓冲信道、mutex、异常处理

目录

• 接口
• 并发与协程
• 信道、缓冲信道
• mutex
• 异常处理

接口

1.实现多个接口
2.接口嵌套
3.接口零值
package main
 
import "fmt"
 
// 接口
 
//1   实现多个接口   具体类型可以赋值给多种接口类型
//type Animal interface {
//	run()
//}
//
//type Dog interface {
//	eat()
//}
//
//type MuYangDog struct {
//	name string
//	age  int
//}
//
//func (d *MuYangDog) eat() {
//	fmt.Println(d.name, "在吃东西")
//}
//func (d *MuYangDog) run() {
//	fmt.Println(d.name, "在跑")
//}
//func main() {
//	//var d Dog = &MuYangDog{name: "牧羊犬", age: 6}
//	//d.eat()
//
//	var a Animal = &MuYangDog{name: "牧羊犬", age: 6}
//	a.run()
//}
 
// 2 接口嵌套
//type Animal interface {
//	run()
//}
//
//type Dog interface {
//	eat()
//	Animal // 就等同于把Animal中的所有方法放在这里了
//}
//type MuYangDog struct {
//	name string
//	age  int
//}
//
//func (d *MuYangDog) eat() {
//	fmt.Println(d.name, "在吃东西")
//
//}
//
//func (d *MuYangDog) run() {
//	fmt.Println(d.name, "在跑")
//
//}
//func main() {
//
//	var d Animal = &MuYangDog{name: "牧羊犬"}
//	d.run()
//}
 
// 2 接口零值---->引用类型
 
type Dog interface {
	eat()
}
type MuYangDog struct {
	name string
	age  int
}
 
func (d *MuYangDog) eat() {
	fmt.Println(d.name, "在吃东西")
 
}
 
func main() {
 
	var d Dog
	fmt.Println(d) // nil
}

并发与协程

# 并发：一段时间内，执行多个任务的能力
# 并行：同一时刻，执行多个任务的能力  （必须有多核支持）
 
# 实现并发
     1 开启多进程（耗费资源）
     2 开启多线程
     3 开启协程
    
# 正常语言，就是开启多线程，实现并发，python由于GIL锁的存在，同一时刻只能有一个线程在执行
     python中计算密集型（耗费cpu）----》开多进程
     pyhton中IO密集型-----》开启多线程
    
    
     其他语言，只要开启了多线程，就能利用多核优势
    
     go语言，进程，线程都不需要，开启协程
         我们认为：开启多个协程，因为在一个线程下，也不能利用多核优势
         所以go内置了，go的协程不是普通协程，它是 线程池+协程
        
        
    GMP模型
         G：go中开启一个协程叫 goroutine   
         P:Processer 处理器（相当于程序层面的线程）
         M：thread  操作系统线程

package main
 
import (
	"fmt"
	"time"
)
 
// 协程
 
func task(i int) {
	fmt.Println("我是任务，我开始干活了", i)
	time.Sleep(2 * time.Second)
	fmt.Println("我是任务，干完活了", i)
 
}
 
func main() {
	fmt.Println("我是主协程")
	//// 执行任务，同步执行
	//task()
 
	// 执行任务，异步执行  ，开启了一个go协程
	//go task()
	//go task()
	//go task()
	//go task()
 
	for i := 0; i < 10; i++ {
		go task(i)
 
	}
	time.Sleep(3 * time.Second)
	fmt.Println("我是主协程，任务执行完了")
 
}

信道、缓冲信道

# 多个goroutine之间通信
	-可以通过共享变量--->mutex保证并发安全
    -信道,通道 channel
    
# 不要通过共享内存来通信，而应该通过通信来共享内存

package main
 
// 信道  一种类型，定义成变量，可以多个协程之间使用
 
//func main() {
//1 定义信道--->没有初始化，零值 是nil，说明引用类型，传递到函数中，不需要取地址
//var c chan int
//fmt.Println(c) // nil
 
// 2 定义并初始化
//var c chan int = make(chan int)
//fmt.Println(c) // 0xc00005c060  内存地址，引用
 
// 3 初始化后，放值，取值
// 放值
//c <- 1 // 把数字1 放入到信道c 中   //deadlock
//c <- 2
//c <- 3
 
// 取值
//var i int=<-c
//var i =<-c
//i := <-c //从信道中取出一个值
//fmt.Println(i)
 
// 4 信道默认，放值取值都是阻塞的，多个协程，一个协程放，另一个协程取值，才不会死锁
//	var c = make(chan int)
//	fmt.Println("主goroutine开始起来")
//	go sendEmail(c) // 把信道变量，传入协程函数中
//
//	//<-c // 等待从c中取值   取出来，不要了
//	i := <-c // 等待从c中取值
//	fmt.Println("主goroutine结束了", i)
//
//}
//
//func sendEmail(c chan int) {
//	fmt.Println("发邮件了")
//	time.Sleep(3 * time.Second)
//	fmt.Println("邮件发完了")
//	c <- 1 // 发完邮件了，放1进去
//
//}
 
// 5 单向信道 （只能放或只能取
 
//func main() {
//	var c = make(chan bool)
//	fmt.Println(<-c)
//}
//
//// func task3(c <-chan bool) {    // 只读信道
//func task3(c chan<- bool) { // 只写信道
//	time.Sleep(2 * time.Second)
//	//c <- true
//	//<-c
//
//}
 
// 6 关闭信道 ，关闭后，不能再放值，取值了   close 内置函数关闭
//
//func task4(c chan int) {
//	time.Sleep(2 * time.Second)
//	c <- 1
//	close(c) // 信道关闭
//}
//
//func main() {
//	var c = make(chan int)
//
//	go task4(c)
//	for {
//		v, ok := <-c
//		if ok {
//			fmt.Println("信道没关闭，取出来了")
//			fmt.Println(v)
//		} else {
//			fmt.Println("信道被关了，结束死循环")
//			break
//		}
//	}
//}
 
// 6.1 稍微复杂的信道关闭
 
//func task4(c chan int) {
//	for i := 0; i < 10; i++ {
//		c <- i
//	}
//
//	close(c) // 信道关闭
//}
//
//func main() {
//	var c = make(chan int)
//
//	go task4(c)
//	for {
//		v, ok := <-c
//		if ok {
//			fmt.Println("信道没关闭，取出来了")
//			fmt.Println(v)
//		} else {
//			fmt.Println("信道被关了，结束死循环")
//			break
//		}
//	}
//}
 
// 6.2 上面是for死循环，可以使用range循环
//func task4(c chan int) {
//	for i := 0; i < 10; i++ {
//		c <- i
//	}
//
//	close(c) // 信道关闭
//}
//
//func main() {
//	var c = make(chan int)
//
//	go task4(c)
//	for i := range c { //只要信道关闭了，循环就结束了
//		fmt.Println(i)
//	}
//}
package main
 
import (
	"fmt"
	"sync"
)
 
//WaitGroup:等待其他协程执行完成
 
// 1 通过信道实现，等待所有任务执行完成
//func task5(c chan int, i int) {
//	fmt.Println("第", i, "个协程执行")
//	c <- i
//}
//
//func main() {
//	var c = make(chan int, 5)
//	for i := 0; i < 5; i++ {
//		go task5(c, i)
//	}
//
//	// 等都执行完才结束
//	for i := 0; i < 5; i++ {
//		<-c
//	}
//	fmt.Println("主协程结束了")
//}
 
// 2 通过  等待所有协程执行完成
func task5(wg *sync.WaitGroup, i int) {
	fmt.Println("第", i, "个协程执行")
	wg.Done() // 这个任务完成，就写一个Done
 
}
 
func main() {
	var wg sync.WaitGroup // 值类型  没有初始化
	//fmt.Println(wg)
	wg.Add(5)
	for i := 0; i < 5; i++ {
		//wg.Add(1)        // 执行5次
		go task5(&wg, i) //一定要取地址
	}
 
	wg.Wait()
	fmt.Println("主协程结束了")
}
 
/*
WaitGroup:等待其他协程执行完成
用法：定义   值类型
wg.Add(1)   开启一个协程，就要加1
 
wg.Done()  一个协程结束，就Done一次，其实就是减一
 
wg.Wait()  等待计数器为0，继续往后执行
*/

mutex

# go 可以通过共享变量，实现通信
package main
 
import (
	"fmt"
	"sync"
)
 
var x = 0
 
func add(wg *sync.WaitGroup, lock *sync.Mutex) {
	// 临界区要加锁
	lock.Lock()
	x = x + 1
	lock.Unlock()
	wg.Done()
}
func main() {
	var w sync.WaitGroup
	var lock sync.Mutex // 值类型
	//fmt.Println(lock)
	for i := 0; i < 1000; i++ {
		w.Add(1)
		go add(&w, &lock)
	}
	w.Wait()
	fmt.Println("final value of x", x)
}

异常处理

package main
 
import "fmt"
 
// 异常处理  go 没有try语法，使用panic，defer，recover实现异常处理
 
func main() {
 
	// 1 panic   内置函数，主动抛出异常，   raise
	//fmt.Println("111")
	//panic("我错了")
	//fmt.Println(222)
 
	// 3 defer 先注册后调用，即便出了异常，也会执行
	// 2 recover 内置函数，回复程序，继续执行
 
	//defer func() {
	//	recover() // 恢复程序
	//}()
	//fmt.Println("111")
	//panic("我错了")
	//fmt.Println(222)
	//
 
	// 4 正常的go异常处理
	test()
 
}
 
func test() {
	defer func() {
		if err := recover(); err != nil {
			fmt.Println("出错了", err)
		}
 
		// 这是finally执行的地址
		//fmt.Println("文论是否出错，我都会执行")
	}()
 
	fmt.Println("test执行了")
	//panic("报错了")
	//var s []int
	//fmt.Println(s[9])
	fmt.Println("test结束了")
}
 
// 其他语言
/*
try:
	写代码
except Except as e:
	出错了
finally：
	都会执行
*/
 
// go
/*
defer func() {
	if err := recover(); err != nil {
		出错了，err就是e，就是错误对象
	}
	都会执行
}()
写代码写代码写代码写代码写代码写代码
 
*/