go基础I

Go语言

数据类型

基本数据类型:int,float,string(不可变),bool,byte
复杂数据类型：struct,map,slice,数组，函数指针，类型指针

赋值，函数传递都是值复制的，顺便思考一下指针

值复制，说明是会在内存中开辟一段内存去复制值的内容，那他们的指针是必然是不一样的

type student struct {
	name string
	age int
}

// 赋值指针不一样的
func main()  {
	s:=student{name: "小明",age: 32}
	s1:=s
	fmt.Printf("s指针为%p\n",&s) // 0xc000004460
	fmt.Printf("s1指针为%p\n",&s1) // 0xc000004480
	copy(s)
}

func copy(s2 student)  {
	fmt.Printf("s2指针为%p\n",&s2) // 0xc0000044c0
}

再次探讨复制,那复制是深复制还是浅复制呢

type Course struct {
	courseName string
}
type Student struct {
	name string
	age int
	course Course
	
}


func main()  {
	s:=Student{name: "小明",age: 32,course: Course{courseName: "数学",
	}}
	s1:=s
	fmt.Printf("s指针为%p\n",&s)
	fmt.Printf("s1指针为%p\n",&s1)



	fmt.Printf("s的course指针为%p\n",&(s.course))
	fmt.Printf("s1的course指针为%p\n",&(s1.course))
}

答案

s指针为0xc00005c360
s1指针为0xc00005c390
s的course指针为0xc00005c378
s1的course指针为0xc00005c3a8

如果Course是指针呢

type Course struct {
	courseName string
}
type Student struct {
	course *Course
	name string
	age int
}


func main()  {
	s:=Student{name: "小明",age: 32,course: &Course{courseName: "数学",
	}}
	s1:=s
	fmt.Printf("s指针为%p\n",&s)
	fmt.Printf("s1指针为%p\n",&s1)


	fmt.Println()
	fmt.Printf("s的course指针为%p\n",s.course)
	fmt.Printf("s的course指针为%p\n",s.course)


	fmt.Println()
	fmt.Printf("s的course指针的指针为%p\n",&(s.course))
	fmt.Printf("s1的course指针的指针为%p\n",&(s1.course))


	fmt.Println()
	fmt.Printf("s指针为%p\n",&s)
	fmt.Printf("s的course指针的指针为%p\n",&(s.course)) // 思考一下如果结构体Student中的course位置改变答案一样吗
}

答案

s指针为0xc000004460
s1指针为0xc000004480

s的course指针为0xc0000321d0
s的course指针为0xc0000321d0

s的course指针的指针为0xc000004460
s1的course指针的指针为0xc000004480

s指针为0xc000004460
s的course指针的指针为0xc000004460

内存简易结构图为

小结一下:
1.对于结构体而言，s:=student{}是直接找引用的，引用是什么，我的理解是就是结构体在内存中的内存地址，只是s被识别为结构体了，在拷贝时候是整一个结构体进行拷贝了，而指针只是内存地址，为8字节复制只有8个字节，但引用最终还是找的是内存地址,例如s.age相当于找的是（0x0001+2）地址的内容
2.在大结构体中拷贝是需要开辟一个新的大结构内存的，指针只需要8字节，在值传递中指针更省内存
3.频繁使用指针可能会影响go的垃圾回收时机

数组和切片

import "fmt"
func main()  {
	var nums [5]int=[5]int{1,2,3,4,5} // 建立数组
	var mySlice []int=nums[:] // 转化为切片
	mySlice[2]=123456
	fmt.Println(mySlice)
	fmt.Println(nums) // 发现数组被改了
}

内存结构

切片的基本操作

import (
	"fmt"
)

func main()  {
	var nums [5]int=[5]int{1,2,3,4,5} // 建立数组
	var mySlice []int=nums[:] // 转化为切片
	
	mySlice1:=make([]int,5) // 通过make去初始化空间,相当于执行构造函数
	fmt.Println(mySlice1) // [0 0 0 0 0]
	
	add(&mySlice)
	fmt.Println(mySlice) // [1 2 3 4 5 2]
	deleteFirst(&mySlice)
	fmt.Println(mySlice) // [2 3 4 5 2]
	deleteLast(&mySlice)
	fmt.Println(mySlice) //[2 3 4 5]
}

// add 添加元素
func add(mySlice *[]int)  {
	*mySlice=append(*mySlice,2)
}

// deleteFirst 删除第一个元素
func deleteFirst(mySlice *[]int)  {
	*mySlice=append((*mySlice)[:0],(*mySlice)[1:]...)
}

// deleteLast 删除最后一个元素
func deleteLast(mySlice *[]int)  {
	*mySlice=append((*mySlice)[0:len(*mySlice)-1],(*mySlice)[len(*mySlice):]...)
}

map的基本操作

func main()  {
	hashMap:=make(map[int]string,10)
	hashMap[1]="小明"
	hashMap[2]="小红"
	hashMap[3]="小刚" // put一个节点到哈希表中
	fmt.Println(hashMap[1]) // get哈希表某一个值
	for index,v:=range hashMap { // 遍历哈希表的值
		if index != 1 {
		fmt.Println(v)
		}
	}
}

闭包

闭包说白了就是一个函数返回一个匿名函数，这个匿名函数有只属于这个函数的数据,可以理解为这个闭包函数就是一个对象，数据就是属于对象的一些属性，闭包用途就是将一个数据保存在一个函数中，当真正执行时才调用该数据进行计算

https://www.cnblogs.com/cxying93/p/6103375.html

func f() func()   {
	var sum int=2
	return func() { // 这个匿名函数有一个外部全局变量sum
		sum+=2
		fmt.Println(sum)
	}
}


func main() {
	f1:=f()
	f1() // 4 f1执行了，当sum还有引用，不会被垃圾回收
	f1() // 6
	f2:=f()
	f2() // 4
	f2() // 6
}

错误处理

go没有像java那样try cacth finally 机制去捕获异常，go更推荐显示判断错误
类似于

if err != nil {
			log.Fatal("Accept error:", err)
}

但也有自己的恐慌回复机制

// 恐慌回复机制
func main()  {
	defer func() { // 该方法进栈
		fmt.Println("正常退出")
	}()
	fmt.Println("嗨！")
	defer func() {  // 该方法进栈
		v := recover() // 恢复恐慌机制
		fmt.Println("恐慌被恢复了：", v)
	}()
	panic("拜拜！") // 产生一个恐慌
	fmt.Println("执行不到这里")
}

恐慌是可以被替换的,一个函数只能有一个恐慌,新恐慌可以替换旧的恐慌

func main()  {
	defer func() {
		if err := recover();err!=nil{
			fmt.Println(err)
		}
	}()
	defer func() {
		a:=1/0
		fmt.Println(a)
	}()
	defer panic(1)
	panic(0)
}

结果为除零异常

.\case8.go:12:7: division by zero
note: module requires Go 1.13

模拟当一个协程执行一个函数出现恐慌后,立马开一个协程重启这个函数

func f()  {
	defer func() {
		if err:=recover();err!=nil{
			fmt.Println("重启一个协程处理")
			go f()
			select {}
		}
	}()
	panic("制造一个恐慌")
}

func main()  {
	f()
}

结果就是个复读机了

思考一下一个结构体到底有多大

在java中一个对象除了本身自己的属性，还包含了其他属性，例如对象头，类型指针，对其填充等字节，而go的一个结构体到底有多大呢

type Student struct {
	course Course // 如果是指针，这个结构体大小为多少呢
	c int64
}
type Course struct {
	a int64 // 8字节
	b int64 // 8字节
}
func main()  {
	fmt.Println(unsafe.Sizeof(Student{}))
	fmt.Println(unsafe.Sizeof(Course{}))
}

24
16

student的结构体大小是a+b+c=24字节，Course的结构体大小是a+b=16字节，go貌似没有像java那样有对象头，类型指针这种东西，但有对其填充吗?

type Student1 struct {
	a byte 
	//空3个字节
	b int32 // 需要对其到内存地址为4字节的地址
	c int64 // 8个字节不用填充
}

type Student2 struct {
	a byte // 填充7字节
	c int64
	b int32 // 填充4字节，也称为末尾填充，他会考虑末尾数组
}

func main()  {
	fmt.Println(unsafe.Sizeof(Student1{}))
	fmt.Println(unsafe.Sizeof(Student2{}))
}

16
24

上面两个结构体有相同字段但却有不同的内存大小，Student1填充了3字节，Student2填充了11个字节
为什么会有对其填充呢
1.不是所有硬件都是支持内存随机读取的，cpu是按块读取的，1,2,4,8字节那样读出来，这么设计好处是为了去兼容不同的硬件，也不会出现一个变量出现跨寄存器的情况.
在x086cpu中，一个寄存器的大小是16位的，为了方便读取，通常会一下子读取一个字，即16字节
在汇编是这样子的 mov ax ds:[bx] ,意思是将ds段的第bx段内存地址送入ax寄存器中，bx是也是一个寄存器，而且bx通常像指令寄存器ip那样，对于一段连续内存中，会自增一个字去读下一个字节

汇编学习资料

https://www.bilibili.com/video/av9285860/

下面是计算内存2000:0000到2000:0007内存的值存到寄存器dx中
cpu寻址方式由两个寄存器配合的 (ds)<<4+bx 这样就可以实现16位的cpu(64kb)达到20的寻址能力(1MB)

 mov cx 4
 mov bx 0
 mov dx 0
 mov ds 2000
 s:add dx [bx]
   add bx 2
 loop s

上面的例子只是想说明cpu是习惯一个字一个字读的，如果不填充，很有可能一个结构体的一个字段需要读两次才能解析出来，这多麻烦，现在32位计算机一个字是4个字节，要求对其填充的字节是4字节，而64位计算机就需要8个字节了。
总结一下，结构体对其填充其实是为了cpu更好的寻址去读内存,结构体也没有像java那么复杂
这里有一个疑问，如果没有像java那样的类型指针，那在反射中，我们在内存中是怎么存储我们结构体类型呢，例如一个结构体类型我们必须的知道他是哪一个结构体类型吧，反射调用才能在内存中查到吧，还有函数调用的地址是在内存是怎么体现的，这里先打一个小小的疑问。

并发编程

go有一句话是不要用共享内存进行通信(java语言)，而是通过通信共享内存，go携程与携程通信通过管道 chan进行通信，他其实就是一个先进先出的阻塞队列，和java上的BlockQueue的功能其实类似的，但是java风格还是倾向与各种锁去控制并发。

下面是基于go101管道案例大全挑选出的一些例子。

future案例

type future struct {
	 stream chan int
}

// 做业务逻辑
func (this *future) set(value int) {
	time.Sleep(time.Second*2)
	this.stream<-value
}

func (this *future) get() int {
	return <-this.stream
}

func main()  {
	f:=future{stream:make(chan int,1)}
	go f.set(3)
	fmt.Println(f.get())
}

lock案例

type Lock struct {
	stream chan struct{}
}
var group sync.WaitGroup 
var sum int

func NewLock() *Lock {
	return &Lock{stream: make(chan struct{},1)}
}

func (this *Lock) Unlock()  {
	<-this.stream
}
func (this *Lock) Lock() {
	this.stream<- struct{}{}
}
func main()  {
	group.Add(10000)
	lock:=NewLock()
	for i:=0;i<10000;i++{
		go func() {
			lock.Lock()
			defer func() {
				group.Done()
				lock.Unlock()
			}()
			sum++
		}()
	}
	group.Wait()
	fmt.Println(sum)
}

最快响应模型:

func doSoming(stream chan int)  {
	a,b:=rand.Int31(),(rand.Intn(10)+1)
	time.Sleep(time.Second*time.Duration(b))
	stream<-int(a)
}

func main()  {
	startTime:=time.Now()
	stream:=make(chan int,5)
	for i:=0;i<5;i++{
        go doSoming(stream)
	}
	ans:=<-stream
	fmt.Println(time.Since(startTime))
	fmt.Println(ans)
}