1、Go语言概述

  • Google开源
  • 编译型
  • 21世纪的C语言

Go和C的比较：https://hyperpolyglot.org/c

特性：

  • 语法简介
  • 开发效率高 - 自带垃圾回收
  • 执行性能好

2、Go语言开发环境搭建

2.1 下载

Go官方下载地址：https://golang.org/dl/

2.2 项目结构

Go语言的项目，需要特定的目录结构进行管理，不能随便写，一个标准的go工程需要三个目录：

  • src：存放我们自己的源代码
  • bin：编译之后的程序之后，使用标准命令go install之后存放的位置
  • pkg：缓存包

GOPATH：一般是我们的项目位置

GOROOT：类似JAVA_HOME

个人开发

Go - 图1

企业开发

Go - 图2

3.3 Go开发编辑器

VS Code下载地址：https://code.visualstudio.com/Download

3.4 编译 - go build

  1. 在项目目录下执行go build
  2. 其他路径下执行go build，需要在后面加上项目路径（src目录只有的路径开始写），将保存到当前目录下
  3. go build -o hello.exe，指定名称

3.5 go run

  • 像执行脚本一样执行go代码

3.6 go install

go install分为两步：

  1. go build
  2. 将编译后的文件移动到GOPATH/bin目录中

3.7 交叉编译

Go支持跨平台编译

老师网站

例如：在windows编译一个能在Linux下运行的文件

Go - 图3

Go - 图4

3、Go语言的编码基本结构

  1. package main
  3. import "fmt"
  5. //函数外只能放置标识符（变量/常量/函数/类型）的申明
  6. //fmt.Println("hell") //非法
  8. //程序入口
  9. func main() {
  10.     fmt.Println("hello world")
  11. }

3.1 Go语言的25个关键字

基础数据类型：

  1. int int8 int16 int32 int64
  2. uint uint8 ... uint64
  4. float32 float64

3.2 变量和常量

  • 先申明再使用
  • Go语言中非全局变量申明了必须使用（不使用无法编译）

Go语言的变量申明格式：

<font style="background-color:#FADB14;">var 变量名 变量类型</font>

批量申明：

  1. var (
  2.     name string
  3.     age  int
  4.     isOk bool
  5. )

申明变量同时赋值：

var name string = "zhangsan" 不推荐

类型推导：

var age = 21

间短变量声明：（只能在函数中使用）

s3 := "李四"

匿名变量：_表示

常量：const

iota：类似枚举

  • 在const关键字出现时将会被置为0，const常量中每新增一行，计数加1
  1. const (
  2.     a1 = iota //a1=0
  3.     a2        //a2=1
  4.     _
  5.     a3 //a3=3
  6. )

插队

  1. const (
  2.     a1 = iota //0
  3.     a2 = 100  //100
  4.     a3 = iota //2
  5.     a4        //3
  6. )

多个常量申明在一行

  1. const (
  2.     d1, d2 = iota + 1, iota + 2 //d1=1,d2=2
  3.     d3, d4 = iota + 1, iota + 2 //d3=2,d4=3
  4. )

定义数量级

  1. const (
  2.     _  = iota
  3.     KB = 1 << (10 * iota) //1左移10位  10000000000(二进制) --> 1024(十进制)
  4.     MB = 1 << (10 * iota) //2左移10位
  5.     GB = 1 << (10 * iota) //3左移10位
  6.     TB = 1 << (10 * iota) //4左移10位
  7.     PB = 1 << (10 * iota) //5左移10位
  8. )

4、基本数据类型

4.1 整型

  1. func main() {
  2.     // 十进制
  3.     var a int = 10
  4.     fmt.Printf("%d \n", a) //10
  5.     fmt.Printf("%d \n", a) //1010，%d表示二进制，转换成了二进制
  6.     fmt.Printf("%o \n", a) //转换成八进制
  8.     // 八进制，以0x开头
  9.     i := 077
  10.     fmt.Printf("%d \n", i)
  12.     //十六进制
  13.     i1 := 0x1234567
  14.     fmt.Printf("%d \n", i1)
  16.     //查看变量的类型
  17.     fmt.Printf("%T \n", i1)
  19.   //申明int8类型的变量
  20.     i3 := int8(9)
  21.     fmt.Printf("%T \n", i3)
  22. }

4.2 浮点数

  • Go语言中默认的浮点数是float64类型

4.3 复数

  • complex64和complex128
  • 复数有实部和虚部，complex64实部和虚部是32，complex128实部和虚部是64

4.4 布尔值

  • true和false（默认值是false）
  • Go语言中不允许将整形和强制转换为布尔型
  • 无法参数运算，无法进行数据类型装换

4.5 占位符

  1. //占位符
  2. func main() {
  3.     var n = 100
  4.     //查看类型
  5.     fmt.Printf("%T /n", n)
  6.     fmt.Printf("%v /n", n)
  7.     fmt.Printf("%b /n", n)
  8.     fmt.Printf("%d /n", n)
  9.     fmt.Printf("%o /n", n)
  10.     fmt.Printf("%x /n", n)
  12.     var s = "你好"
  13.     fmt.Printf("字符串：%s /n", s)
  14.     fmt.Printf("字符串：%v /n", s)
  15.     fmt.Printf("字符串：%#v /n", s)
  16. }

4.6 字符串

Go - 图5

4.7 rune

  1. func main() {
  2.     s := "白萝卜"
  3.     s1 := []rune(s) //转换
  4.     s1[0] = '红'
  5.     fmt.Println(string(s1))
  6. }

4.8 类型转换

4.9 定长数组 - 切片

4.10 不定长数组

4.11 字典 - map

4.12 枚举 - iota

  • Go语言中没有枚举类型，但是我们可以使用const（常量关键字）+iota（常量累加器）来进行模拟
  1. //模拟一个一周的枚举
  2. const (
  3.     MONDAY   = iota //0
  4.     TUESDAY         //1
  5.     WEDNEDAY        //2
  6.     THURSDAY        //...
  7.     FRIDAY
  8.     SATUDAY
  9.     SUNDAY
  10.     M, N = iota, iota     // 7,7
  11.     X, Y = iota + 1, iota // 9,8
  12. )
  14. /*
  15.  1. iota是常量组计数器
  16.  2. iota从0开始，没换行递增1
  17.  3. 常量组不赋值，默认与上一行表达式相同
  18.  4. 如果同一行出现两个iota，那么两个iota的值相同
  19.  5. 每个常量组的iota是独立的，遇到const会清0
  20. */

4.13 结构体 - type + struct

  • 概念类似java中的对象
  1. type 结构体名称 struct{}

4.14 init()函数

  • init()函数没有参数没有返回值
  • 一个包中包含多个init时，调用顺序不确定
  • init()函数不允许被用户显示调用
  • 有时候引用一个包，可能只想使用这个包中的inti函数（mysql的init对驱动进行初始化）
    • 可以使用_在import里处理

4.15 defer关键字 - 延迟

延迟、关键字，可以用于修饰语句，函数，确保这条语句可以在当前栈退出时执行

4.16 结构体（类）- 方法绑定 —> 封装

  1. //Go语言中的结构体就好比java/C中的类
  2. //结构体的定义为：type 结构体名 struct{}
  4. //Go语言中的方法不是定义在类里面
  5. //Go语言是面向接口的不是面向类的
  6. //Go语言的方法通过绑定类实现的（定义在类的外面）
  8. //定义结构体（类）
  9. type Person struct {
  10.     name   string
  11.     age    int
  12.     gender string
  13.     score  float64
  14. }
  16. //定义方法绑定person类
  17. func (p *Person) Eat() {
  18.     //尽量使用指针传递
  19.     fmt.Println(p.name + "吃的真香！")
  20. }

4.17 继承

  1. package main
  3. import "fmt"
  5. // 继承
  7. //定义一个Human（人）类
  8. type Human struct {
  9.     name   string
  10.     age    int
  11.     gender string
  12.     scode  float64
  13. }
  15. //定义Human的方法
  16. func (h *Human) Eat() {
  17.     fmt.Println(h.name + "吃的吧唧香....")
  18. }
  20. //定义一个学生类 -- 类的嵌套
  21. type Student struct {
  22.     //包含Human类型的变量（类的嵌套）
  23.     hum    Human
  24.     school string
  25. }
  27. //定义一个老师类 -- 继承Human
  28. type Teacher struct {
  29.     //继承的时候虽然没有定义字段名字，但是会自动创建一个默认的同名字段
  30.     //这是为了在子类中依然可以操作父类，因为子类父类中可能存在同名的字段
  31.     Human   //直接写父类名称，没有字段名字
  32.     subject string
  33. }
  35. func main() {
  36.     stu1 := Student{
  37.         hum: Human{
  38.             "狗娃",
  39.             19,
  40.             "男",
  41.             89.0,
  42.         },
  43.         school: "人民一中",
  44.     }
  45.     fmt.Println(stu1)
  47.     //类的继承
  48.     t1 := Teacher{}
  49.     t1.name = "强国"
  50.     t1.age = 19
  51.     t1.subject = "语文"
  52.     t1.Eat()
  53.     fmt.Println(t1)
  54. }

4.18 Go中的权限

  • Go语言中权限都是通过首字母大小写控制
    • import —> 如果包名不同，那么只有大写字母开头的才是public的
    • 类成员、方法 —> 只有首写字母大写才能在其他包中使用

4.19 接口

  • Go语言中使用interface关键字创建接口
  • interface 不仅仅是用来处理多态的，他可以接收任何类型的数据类型，有点类似于void
  1. func main() {
  2.     //定义三个接口类型
  3.     var i, j, k interface{} //空接口
  4.     names := []string{"duke", "lily"}
  5.     i = names
  6.     fmt.Println("i代表切片数组：", i)
  7.     age := 20
  8.     j = age
  9.     fmt.Println("j代表数字:", j)
  10.     s := "hello"
  11.     k = s
  12.     fmt.Println("k代表字符串：", k)
  14.     //现在我们只知道k是interface类型，但是我们不知道具体代表什么类型？可以进行判断
  15.     kvalue, ok := k.(int)
  16.     if !ok {
  17.         fmt.Println("k不是int")
  18.         fmt.Printf("k的类型是：%T\n", k) //k的类型是：string
  19.         fmt.Printf("i的类型是：%T\n", i) //i的类型是：[]string
  20.         fmt.Printf("j的类型是：%T\n", j) //j的类型是：int
  21.     } else {
  22.         fmt.Println("k是int，k的值：", kvalue)
  23.     }
  24. }
  • 常用的场景：把interface当做一个函数的参数，（类似于print），使用switch来判断用户输入的不同类型，在根据不同的类型，做相应的逻辑处理
  1.     //创建具有三个数据类型的切片
  2.     array := make([]interface{}, 3)
  3.     array[0] = 1
  4.     array[1] = "hello"
  5.     array[2] = true
  7.     for _, value := range array {
  8.         switch v := value.(type) {
  9.         case int:
  10.             fmt.Printf("当前类型为%T，内容为：%d\n", v, v)
  11.         case string:
  12.             fmt.Printf("当前类型为%T，内容为：%s\n", v, value)
  13.         case bool:
  14.             fmt.Printf("当前类型为%T，内容为：%v\n", v, value)
  15.         default:
  16.             fmt.Printf("其他数据类型，当前类型为%T，内容为：%v\n", v, value)
  17.         }
  18.     }

4.20 多态

  • Go语言的多态不需要继承，只需要实现相同的接口即可
  1. //Go语言中实现多态，需要实现定义的接口
  3. //人类发起攻击，不同等级子弹效果不同
  4. //创建接口 , 注意类型是interface
  5. type IAttack interface {
  6.     //接口的函数可以有多个，但是只能有函数原型，不可以实现
  7.     Attack()
  8. }
  10. //玩家
  11. type Human struct {
  12.     name  string
  13.     level int
  14.     hurt  float64
  15. }
  17. //定义玩家方法绑定到HumanLowLevel类
  18. func (hum *Human) Attack() {
  19.     fmt.Println("我是：", hum.name, ",我的等级是：", hum.level, "，我造成了", hum.hurt, "点伤害...")
  20. }
  22. //定义一个多态的通用接口，传入不同的对象，调用同样的方法，实现不同效果 ---> 多态
  23. func doIAttack(i IAttack) {
  24.     i.Attack()
  25. }
  27. func main() {
  29.     //定义一个包含IAttack接口变量
  30.     var player IAttack
  32.     //低等级玩家
  33.     lowLevel := Human{
  34.         name:  "David",
  35.         level: 1,
  36.         hurt:  100,
  37.     }
  38.     // lowLevel.Attack()
  40.     //给player赋值为lowLevel，接口一定要使用指针来赋值
  41.     player = &lowLevel
  42.     player.Attack()
  44.     //高等级玩家
  45.     highLevl := Human{
  46.         name:  "狗蛋",
  47.         level: 6,
  48.         hurt:  10000,
  49.     }
  51.     player = &highLevl
  52.     player.Attack()
  53.     fmt.Println("-----多态--------")
  54.     doIAttack(&lowLevel)
  55.     doIAttack(&highLevl)
  56. }

5、Go语言基础之流程控制

5.1 if else

  1.     age := 21
  2.   if age > 35 {
  3.         fmt.Println("人到中年")
  4.     } else if age > 18 {
  5.         fmt.Println("好青年")
  6.     } else {
  7.         fmt.Println("小盆友")
  8.     }
  10. # 特殊写法
  11. 减少程序内存的占用
  12.     if age := 19; age > 35 { //作用域，age的作用范围仅限于if条件判断语句中
  13.         fmt.Println("人到中年")
  14.     } else if age > 18 {
  15.         fmt.Println("好青年")
  16.     } else {
  17.         fmt.Println("小盆友")
  18.     }

5.2 for

  • Go语言中只有一种循环（for循环）

格式：

  1. for 初始语句;条件表达式；结束语句{
  2.     循环体语句
  3. }
  5. // 变种1
  6. i:= 5
  7. for ;i<10;i++{
  8.     fmt.Println(i)
  9. }
  11. // 变种2
  12. j:=5
  13. for j<10{
  14.     fmt.Println(j)
  15.     j++
  16. }
  18. //无限循环
  19. for {
  20.     fmt.Println("11")
  21. }
  23. //for range循环
  24.     s := "hello沙河"
  25.     for i, v := range s {
  26.         fmt.Printf("%d %c \n", i, v)
  27.     }

6、数据类型

6.1 切片

  • 切片指向了一个底层的数组（切片不存值）
  • 切片的长度是它的元素个数
  • 切片的容量是底层数组从切片的第一个元素到数组的最后一个元素
  • 切片是引用类型，都指向了一个底层数组（修改底层数组的值，切片也将被修改）

6.2 make()函数

make([]T, len, cap)

  • 用来创建切片
  • 函数的指针返回存在内存逃逸

6.3 append()

  • 为切片追加元素
  • 必须用原来的切片变量接收返回值
  • 追加时容量不足，将底层数组换一个比原来数组大（策略：根据类型策略不同）的新数组

6.4 copy()

  • 复制切片

6.5 sort

  • 对切片进行排序

6.6 指针

  • Go语言中不存在指针操作，只需记住两个符号
    • &：取地址
    • *：根据地址取值

6.7 make和new

  1. 都是用来申请内存的
  2. new很少用，一般用来给基本数据类型申请内存，string/int…，返回的是对应类型的指针（string、int）
  3. make用来给slice、map、chan申请内存，make函数返回的对应的这三个类型本身

6.8 map

map[keyType]valueType

7、结构体（类似java的类）

  1. type 类型名 结构体类型{
  2.     字段 数据类型
  3.     字段 数据类型
  4. }

例如：

  1. package main
  3. import "fmt"
  5. //结构体
  7. type person struct {
  8.     name   string
  9.     age    int
  10.     gender string
  11.     hobby  []string
  12. }
  14. func main() {
  15.     //申明person类型变量
  16.     var p person
  17.     //赋值
  18.     p.name = "zhoulin"
  19.     p.age = 21
  20.     p.gender = "女"
  21.     p.hobby = []string{"篮球", "足球", "乒乓球"}
  22.     //访问变量
  23.     fmt.Println(p)      //{zhoulin 21 女 [篮球 足球 乒乓球]}
  24.     fmt.Println(p.name) //zhoulin
  25. }

7.1 匿名结构体

  • 多用域临时场景
  1. var 变量名 struct{
  2.     变量 数据类型
  3.     ...
  4. }

7.2 结构体指针和结构体初始化

  • 结构体是值类型
  • Go语言中函数传参永远是拷贝
  • 结构体占用一块连续的内存空间
  1. type person struct {
  2.     name   string
  3.     age    int
  4.     gender string
  5. }
  7. func f(x person) {
  8.     x.gender = "男" //修改的是副本的gender
  9. }
  11. func f2(x *person) {
  12.     // (*x).gender = "男" //根据内存地址找到原来的变量，修改的是原来的变量的值
  13.     x.gender = "男" //指针的语法糖，与上面相同找到原来的变量修改
  14. }
  16. func main() {
  17.     var p person
  18.     p.name = "zhoulin"
  19.     p.age = 17
  20.     p.gender = "女"
  21.     f(p)
  22.     fmt.Println(p) //{zhoulin 17 女}
  23.     f2(&p)         //传递的是p的内存地址
  24.     fmt.Println(p) //{zhoulin 17 男}
  25. }

Go - 图6

7.3 构造函数

  • 返回一个结构体变量的函数
  1. //构造函数
  2. type person struct {
  3.     name string
  4.     age  int
  5. }
  7. //构造函数返回的是结构体还是结构体指针？
  8. //当结构体比较大的时候尽量使用结构体指针，减少程序的内存开销
  9. func newPerson(name string, age int) *person {
  10.     return &person{
  11.         name: name,
  12.         age:  age,
  13.     }
  14. }
  16. func main() {
  17.     p1 := newPerson("元帅", 18)
  18.     p2 := newPerson("周林", 21)
  19.     fmt.Println(p1)
  20.     fmt.Println(p2)
  21. }

8、结构体

  1. //方法
  3. type dog struct {
  4.     name string
  5. }
  7. //构造函数
  8. func newDog(name string) dog {
  9.     return dog{
  10.         name: name,
  11.     }
  12. }
  14. //方法是作用与特定类型的函数
  15. //接收者表示的是调用方法的具体变量，多用类型名首字母小写表示
  16. func (d dog) wang() {
  17.     fmt.Printf("%s: 汪汪汪~", d.name)
  18. }
  20. func main() {
  21.     d1 := newDog("大黄")
  22.     d1.wang()
  23. }
  • Go语言中如果标识符的首字母大写，表示对外部包可见（暴露的，共有的）

何时使用指针接收者：

  • 值接收者，需要修改接收者中的值时需要指针接收者
  • 尽量使用指针接收者

8、基础语法

8.1 switch

8.2 标签

8.3 枚举const-iota

8.4 结构体

8.5 init函数

8.6 defer（延迟）

9、类的相关操作

9.1 封装 — 方法绑定

9.2 类继承

9.3 interface（接口）

9.4 多态

10、并发相关

10.1 基础

  • Go语言中不是线程，而是go程 ==> goroutine，go程是go语言原生支持的
  • 每一个go程占用系统资源远远小于线程，一个go程大约需要4~5k的内存资源
  • 一个程序可以启动大量的go程：
    • 线程 ==> 几十个
    • go程可以启动成百上千个，===>实现高并发，性能非常好
    • 只需要在函数前面加上go关键字即可
  1. //用于子go程使用
  2. func display() {
  3.     count := 1
  4.     for {
  5.         fmt.Println("这是子go程：", count)
  6.         count++
  7.         // time.Sleep(500) //默认为微秒
  8.         time.Sleep(1 * time.Second)
  9.     }
  10. }
  12. func main() {
  13.     //启动子go程
  14.     go display()
  16.     //主go程
  17.     count := 1
  18.     for {
  19.         fmt.Println("============>这是主go程：", count)
  20.         count++
  21.         time.Sleep(1 * time.Second)
  22.     }
  23. }

启动多个子go程，竞争资源

  1. //用于子go程使用
  2. func display(num int) {
  3.     count := 1
  4.     for {
  5.         fmt.Println("这是子go程：", num, "当前执行的次数：", count)
  6.         count++
  7.         // time.Sleep(500) //默认为微秒
  8.         time.Sleep(1 * time.Second)
  9.     }
  10. }
  12. func main() {
  13.     //启动子go程
  14.     for i := 1; i <= 3; i++ {
  15.         go display(i)
  16.     }
  18.     //主go程
  19.     count := 1
  20.     for {
  21.         fmt.Println("============>这是主go程：", count)
  22.         count++
  23.         time.Sleep(1 * time.Second)
  24.     }
  25. }

10.2 提前退出go程序

  1. /*
  2.     GOEXIT：提前退出当前go程序
  3.     return：返回当前函数
  4.     exit：退出整个程序（进程）
  5. */
  6. func main() {
  7.     //匿名函数创建go程
  8.     go func() {
  9.         func() {
  10.             fmt.Println("这是子go程内部的函数...")
  11.             // return //返回当前函数
  12.             // os.Exit(1) //退出程序
  13.             runtime.Goexit() //退出当前go程
  14.         }()
  15.         fmt.Println("子go程结束!")
  16.     }()
  17.     fmt.Println("这是主go程!")
  18.     time.Sleep(3 * time.Second)
  19.     fmt.Println("OVER!!")
  20. }

10.3 无缓冲管道channel

  1. func main() {
  3.     /*
  4.         当涉及多个go程时，c语言使用互斥量，上锁来保证资源同步，避免资源竞争
  5.         Go语言也支持这种方式，但是Go语言更好的解决方案是使用管道（通道：channel）
  6.         使用管道不需要我们去加锁
  8.         例如：读写数据的同步
  9.     */
  11.     //创建装数字的管道，创建管道一定要用make，同map一样，否则是nil
  12.     //不指定长度，此时是无缓存的管道
  13.     // numChan := make(chan int) //五缓冲
  14.     numChan := make(chan int, 10) //有缓冲
  16.     //子进程读数据
  17.     go func() {
  18.         for i := 0; i < 50; i++ {
  19.             //numChan写入数据向data
  20.             data := <-numChan
  21.             fmt.Println("子进程1，读取数据：", data)
  22.         }
  23.     }()
  25.     //子进程写入数据到管道numChan中
  26.     go func() {
  27.         for i := 0; i < 20; i++ {
  28.             numChan <- i
  29.             fmt.Println("子进程2写书数据：", i)
  30.         }
  31.     }()
  33.     //主进程写数据
  34.     for i := 20; i < 50; i++ {
  35.         //i写入数据到管道numChan
  36.         numChan <- i
  37.         fmt.Println("主进程写入数据：", i)
  38.     }
  39. }

10.4 有缓冲管道

死锁

  1. func main() {
  2.     //1.当缓冲写满后，写阻塞，等到读取后，再恢复写入
  3.     //2.当缓冲区空时，读阻塞，直到有数据写入
  4.     //3.如果管道没有使用make分配空间，那么管道默认是nil的，读写都会阻塞
  5.     // numChan := make(chan int, 10)
  7.     var names chan string //默认是nil的
  9.     //读数据
  10.     go func() {
  11.         fmt.Println("数据是：", names)
  12.     }()
  14.     //写数据
  15.     names <- "hello"
  16. }

初始化空间

  1. func main() {
  2.     //1.当缓冲写满后，写阻塞，等到读取后，再恢复写入
  3.     //2.当缓冲区空时，读阻塞，直到有数据写入
  4.     //3.如果管道没有使用make分配空间，那么管道默认是nil的，读写都会阻塞
  5.     //4.对于管道，读写次数必须对等
  6.     //不对等：一、主程序读的数大于写的，程序奔溃死锁；二、子程序读大于写，不会奔溃，内存泄露
  8.     // numChan := make(chan int, 10)
  10.     // var names chan string         //默认是nil的
  11.     // names = make(chan string, 10) //分配空间
  13.     //合并上面
  14.     names := make(chan string, 10)
  16.     //读数据
  17.     go func() {
  18.         fmt.Println("数据是：", <-names)
  19.     }()
  21.     //写数据
  22.     names <- "hello" //由于这里是names是nil，写操作会阻塞在这里
  23.     time.Sleep(1 * time.Second)
  24. }

解决读写不对等 - for-range

  • close()
  1. func main() {
  2.     numChan2 := make(chan int, 10)
  4.     //写
  5.     go func() {
  6.         for i := 0; i < 50; i++ {
  7.             numChan2 <- i
  8.             fmt.Println("写入数据：", i)
  9.         }
  10.         close(numChan2)
  11.     }()
  13.     //读，遍历管道时，只返回一个参数
  14.     //问题：for-range不知道管道是否已经写完了，所以会一直等待（奔溃）--->写时，显示关闭管道close
  15.     //在写入端，将管道关闭，for-range遍历时关闭管道，会退出
  16.     for v := range numChan2 {
  17.         fmt.Println("读数据：", v)
  18.     }
  19.     fmt.Println("over!")
  20. }

10.5 for range遍历

  1. func main() {
  2.     numChan2 := make(chan int, 10)
  4.     //写
  5.     go func() {
  6.         for i := 0; i < 50; i++ {
  7.             numChan2 <- i
  8.             fmt.Println("写入数据：", i)
  9.         }
  10.         close(numChan2)
  11.     }()
  13.     //读，遍历管道时，只返回一个参数
  14.     //问题：for-range不知道管道是否已经写完了，所以会一直等待（奔溃）--->写时，显示关闭管道close
  15.     //在写入端，将管道关闭，for-range遍历时关闭管道，会退出
  16.     for v := range numChan2 {
  17.         fmt.Println("读数据：", v)
  18.     }
  19.     fmt.Println("over!")
  20. }

10.6 管道总结

  • 当管道写满了，写阻塞
  • 当缓冲区读完了，读阻塞
  • 如果管道没有使用make分配空间，管道默认是nil
  • 从nil的管道读取数据、写入数据、都会阻塞（不会奔溃）
  • 从一个已经close的管道读数据时，会反馈零值（不会奔溃）
  • 向一个已经close的管道写数据是，会奔溃
  • 关闭一个已经关闭的管道，程序会奔溃
  • 关闭管道的动作一定要在写管道的一端，不应该放在读端，否则写端继续写，会奔溃
  • 读写次数一定要对等，否则：
    • 在多个go程中：资源泄露
    • 在主go程中，程序奔溃（deadlock）

10.7 多go程序读写

略（上面已经实现）

10.8 判断管道是否已关闭

  • 需要知道一个管道的状态，如果已经close了，读不怕（返回0），如果写（奔溃）

判断和map中是否有值很类似

  • map：v,ok := m1[0]
  • chan：v,ok := <- numchan 
  1. func main() {
  2.     numChan := make(chan int, 10)
  4.     //写
  5.     go func() {
  6.         for i := 0; i < 10; i++ {
  7.             numChan <- i
  8.             fmt.Println("写数据：", i)
  9.         }
  10.         close(numChan)
  11.     }()
  13.     //读
  14.     // for v := range numChan {
  15.     //     fmt.Println("读数据：", v)
  16.     // }
  18.     for {
  19.         v, ok := <-numChan //ok-idom判断模式
  20.         if !ok {
  21.             fmt.Println("管道已经关闭了，准备退出...")
  22.             break
  23.         }
  24.         fmt.Println(v)
  25.     }
  26. }

10.9 单向通道

  • numChan := make(chan int,10) ==>双向通道，即可写，也可读
  • 单向通道：为了明确语义，一般用于函数参数
    • 单向读通道：var numChanReadOnly <- chan int
    • 单向写通道：var numChanWriteOnly chan <- int
  1. // consumer：消费者 --->只读
  2. func consumer(in <-chan int) {
  3.     for v := range in {
  4.         // in <- v //读通道不允许写操作
  5.         fmt.Println("消费者消费：", v)
  6.     }
  7. }
  9. // producer：生产者 --->只写
  10. func producer(out chan<- int) {
  11.     for i := 0; i < 10; i++ {
  12.         out <- i
  13.         fmt.Println("生产者生产：", i)
  14.     }
  15. }
  16. func main() {
  17.     //单向读通道
  18.     // var numChanReadOnly <-chan int
  19.     //单向写通道
  20.     // var numChanWriteOnly chan<- int
  22.     //生产者消费者模型
  23.     //C语言：数组+锁  thread1：写，thread2：读
  24.     //Go语言：goroutine + channel
  26.     //1.在主函数中创建一个双向channel：numChan
  27.     numChan := make(chan int, 5)
  28.     //2.将numChan传递给生产者，生产
  29.     go producer(numChan) // 双向通道可以赋值给同类型的单向通道
  30.     //3.将numChan传递给消费者，消费
  31.     go consumer(numChan)
  33.     time.Sleep(2 * time.Second)
  34.     fmt.Println("OVER!")
  35. }

10.10 select

当程序总有多个channel协同工作时，ch1，chan2，在某时刻，ch1和chan2触发了，程序要做响应的处理

使用select来监听多个通道，当管道被触发时（写入数据，读取数据，关闭管道）

select语法和Switch case很像，但是所有的分支条件都必须是通道io 
  1. package main
  3. import (
  4.     "fmt"
  5.     "time"
  6. )
  8. // 当程序总有多个channel协同工作时，ch1，chan2，在某时刻，ch1和chan2触发了，程序要做响应的处理
  9. // 使用select来监听多个通道，当管道被触发时（写入数据，读取数据，关闭管道）
  10. // select语法和Switch case很像，但是所有的分支条件都必须是通道io
  12. func main() {
  14.     // var chan1, chan2 chan int
  15.     chan1 := make(chan int)
  16.     chan2 := make(chan int)
  18.     //启动1个go程，负责监听两个chan
  19.     go func() {
  20.         for {
  21.             fmt.Println("监听中...")
  22.             select {
  23.             case data1 := <-chan1:
  24.                 fmt.Println("从chan1读取成功，data1：", data1)
  25.             case data2 := <-chan2:
  26.                 fmt.Println("从chan2读取成功，data2：", data2)
  27.             default:
  28.                 fmt.Println("....")
  29.                 time.Sleep(1 * time.Second)
  30.             }
  31.         }
  32.     }()
  34.     //启动go1，写chan1
  35.     go func() {
  36.         for i := 0; i < 10; i++ {
  37.             chan1 <- i
  38.             // fmt.Println("写入chan1：", i)
  39.             time.Sleep(1 * time.Second / 2)
  40.         }
  41.     }()
  43.     //启动go2，写chan2
  44.     go func() {
  45.         for i := 0; i < 10; i++ {
  46.             chan2 <- i
  47.             // fmt.Println("写入chan1：", i)
  48.             time.Sleep(1 * time.Second)
  49.         }
  50.     }()
  51.     for {
  52.         time.Sleep(3 * time.Second)
  53.         fmt.Println("OVER!")
  54.     }
  55. }

11、网络

1. 分层

Go - 图7

OIS七层 TCP/IP四层 对应的网络协议

2. socket

Go - 图8

Server Demo

  • 只能接收一个连接，发送一个数据
  1. package main
  3. import (
  4.     "fmt"
  5.     "net"
  6.     "strings"
  7. )
  9. func Server() {
  10.     //1.创建监听
  11.     ip := "127.0.0.1"
  12.     port := 8848
  13.     address := fmt.Sprintf("%s:%d", ip, port)
  15.     // net.Listen("tcp", ":8848") // 简写，冒号前面默认是ip
  16.     listenner, err := net.Listen("tcp", address)
  17.     if err != nil {
  18.         fmt.Println("net.Listen err:", err)
  19.         return
  20.     }
  22.     //2.建立连接
  23.     //err不会重新创建，而是复用
  24.     conn, err := listenner.Accept()
  25.     if err != nil {
  26.         fmt.Println("listenner.Accept err:", err)
  27.         return
  28.     }
  30.     fmt.Println("连接建立成功！")
  32.     //3.创建一个容器，用于接收读取到的资源
  33.     buf := make([]byte, 1024)
  34.     //cnt真正读取client发来的数据长度
  35.     cnt, err := conn.Read(buf)
  36.     if err != nil {
  37.         fmt.Println("conn.Read err:", err)
  38.         return
  39.     }
  40.     fmt.Println("Client ===> Server，长度：", cnt, "，数据：", string(buf[:cnt]))
  42.     //4.将数据转成大写："hello" ==> "HELLO"
  43.     //服务器对客户端进行响应
  44.     upperData := strings.ToUpper(string(buf))
  45.     cnt, err = conn.Write([]byte(upperData))
  46.     if err != nil {
  47.         fmt.Println("conn.Write err:", err)
  48.         return
  49.     }
  50.     fmt.Println("Client <=== Server，长度：", cnt, "，数据：", upperData)
  52.     // 5.关闭连接
  53.     conn.Close()
  54. }
  56. func main() {
  58.     Server()
  60. }

Client Demo

  1. package main
  3. import (
  4.     "fmt"
  5.     "net"
  6. )
  8. func Client() {
  9.     //1. 建立连接
  10.     conn, err := net.Dial("tcp", ":8848")
  12.     if err != nil {
  13.         fmt.Println("net.Dial err:", err)
  14.         return
  15.     }
  16.     fmt.Println("client与server连接建立成功！")
  18.     //2. 写数据 --> Server
  19.     sendData := []byte("helloworld")
  21.     cnt, err := conn.Write(sendData)
  22.     if err != nil {
  23.         fmt.Println("Client ===> Server cnt:", cnt, ",data:", string(sendData))
  24.     }
  26.     //3. 接收Server返回数据
  27.     buf := make([]byte, 1024)
  28.     cnt, err = conn.Read(buf[:cnt])
  29.     if err != nil {
  30.         fmt.Println("conn.Read err:", err)
  31.     }
  32.     fmt.Println("Client <=== Server cnt:", cnt, ",data:", buf[:cnt])
  34.     // 4. 关闭连接
  35.     conn.Close()
  36. }
  38. func main() {
  39.     Client()
  40. }

多连接

client

  1. package main
  3. import (
  4.     "fmt"
  5.     "net"
  6.     "time"
  7. )
  9. func Client() {
  10.     //1. 建立连接
  11.     conn, err := net.Dial("tcp", ":8848")
  13.     if err != nil {
  14.         fmt.Println("net.Dial err:", err)
  15.         return
  16.     }
  17.     fmt.Println("client与server连接建立成功！")
  18.     for {
  19.         //2. 写数据 --> Server
  20.         sendData := []byte("helloworld")
  22.         cnt, err := conn.Write(sendData)
  23.         if err != nil {
  24.             fmt.Println("Client ===> Server cnt:", cnt, ",data:", string(sendData))
  25.         }
  27.         //3. 接收Server返回数据
  28.         buf := make([]byte, 1024)
  29.         cnt, err = conn.Read(buf[:cnt])
  30.         if err != nil {
  31.             fmt.Println("conn.Read err:", err)
  32.         }
  33.         fmt.Println("Client <=== Server cnt:", cnt, ",data:", buf[:cnt])
  34.         time.Sleep(1 * time.Second)
  35.     }
  36.     // 4. 关闭连接
  37.     // _ = conn.Close()
  38. }
  40. func main() {
  41.     Client()
  42. }

server

  1. package main
  3. import (
  4.     "fmt"
  5.     "net"
  6.     "strings"
  7. )
  9. //处理具体业务的逻辑，需要将conn传递进来，每一个新连接，conn是不同的
  10. func handleFunc(conn net.Conn) {
  11.     //3.创建一个容器，用于接收读取到的资源
  12.     buf := make([]byte, 1024)
  13.     for {
  14.         fmt.Println("准备读取数据....")
  15.         //cnt真正读取client发来的数据长度
  16.         cnt, err := conn.Read(buf)
  17.         if err != nil {
  18.             fmt.Println("conn.Read err:", err)
  19.             return
  20.         }
  21.         fmt.Println("Client ===> Server，长度：", cnt, "，数据：", string(buf[:cnt]))
  23.         //4.将数据转成大写："hello" ==> "HELLO"
  24.         //服务器对客户端进行响应
  25.         upperData := strings.ToUpper(string(buf))
  26.         cnt, err = conn.Write([]byte(upperData))
  27.         if err != nil {
  28.             fmt.Println("conn.Write err:", err)
  29.             return
  30.         }
  31.         fmt.Println("Client <=== Server，长度：", cnt, "，数据：", upperData)
  32.     }
  33.     // 5.关闭连接
  34.     // _ = conn.Close()
  35. }
  37. func Server() {
  38.     //1.创建监听
  39.     ip := "127.0.0.1"
  40.     port := 8848
  41.     address := fmt.Sprintf("%s:%d", ip, port)
  43.     // net.Listen("tcp", ":8848") // 简写，冒号前面默认是ip
  44.     listenner, err := net.Listen("tcp", address)
  45.     if err != nil {
  46.         fmt.Println("net.Listen err:", err)
  47.         return
  48.     }
  50.     //需求：server可以接收多个连接，每个连接可以处理多个请求
  51.     //解：主go程负责监听，子go程负责处理
  53.     //主
  54.     for {
  55.         fmt.Println("监听中...")
  56.         //2.建立连接
  57.         //err不会重新创建，而是复用
  58.         conn, err := listenner.Accept()
  59.         if err != nil {
  60.             fmt.Println("listenner.Accept err:", err)
  61.             return
  62.         }
  64.         fmt.Println("连接建立成功！")
  65.         go handleFunc(conn)
  67.     }
  68. }
  70. func main() {
  71.     Server()
  72. }

3. http

编写web的语言：

  1. java
  2. php ==> 现在用go重写
  3. python ，豆瓣
  4. go ===> beego,gin主流的web框架

https协议：浏览器发送的就是http请求

  1. http是应用层的协议，底层还是依赖传输层：tcp（短连接），网络层（ip）
  2. 无状态的，每次请求都是独立的，下次请求需要重新建立连接
  3. https：
    1. http是标准协议，明文传输，不安全
    2. https不是标准协议，https：http + ssl（非对称加密，数字证书）
    3. 现在所有网站都会尽量要求使用https开发：安全