• Go 语言初探：从基础到实战

    1.Go概述

    程序是一段计算机指令的有序组合。程序=算法+数据结构。任何程序都可以将模块通过三种基本的控制结构（顺序、分支、循环）进行组合来实现。

    Go（也称为Golang）是一种由Google开发的开源编程语言。设计目标是使编程更简单、高效和可靠。Go旨在提供高性能、简洁且易于理解的语法。它结合了传统编译型语言的速度和性能，以及动态类型语言的易用性和便捷性。
    Go语言特性：

    1.静态编译

    2.少即是多，语法简洁简单，可读性强

    3.原生支持并发编程

    4.Duck模型的非侵入式接口

    5.强调组合，组合优于继承

    6.支持多种操作系统和体系结构的交叉编译,这里的 targetOS 是目标操作系统（如 windows、linux、darwin 等），targetArchitecture 是目标体系结构（如 amd64、arm、386 等）。

    GOOS=targetOS GOARCH=targetArchitecture go build
GOOS=windows GOARCH=amd64 go build

    • 1
    • 2

    7.大量使用接口和内置函数来提高代码的复用度

    8.支持和C 语言相互调用的机制（CGO），Go 中使用 C 包来调用 C 函数，以及使用特殊的类型来处理在 Go 和 C 之间传递的数据。以下是一个简单的示例，展示了如何在 Go 中调用 C 函数：

    #include 

void helloFromC() {
    printf("Hello from C!\n");
}

    • 1
    • 2
    • 3
    • 4
    • 5
    package main

/*
#cgo CFLAGS: -g -Wall
void helloFromC();
*/
import "C"

func main() {
    C.helloFromC()
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    9.精确依赖，并通过增量编译、并行编译以及缓存编译结果来缩短编译时间

    Go语言基本命令：

    2.Go基本语法

    Go语言中共有25个关键字，是静态强类型语言。

    强类型：编译器会确认每个变量应有的类型，错误使用将引发错误；

    静态：仅支持编译时自动推断类型

    在这里插入图片描述

    Go语言中的条件语句，if判断后面不需要()，同时if可带一个初始化子语句用；跟条件分开。同时Go也不支持三元运算符

    /*
if SimpleStmt;Expression {
	statement
	......
}
*/
if i:=10;i>8 {
    //条件语句
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    switch语句说明：

    注意：math.Floor(num)函数用于返回小于num的最小整数

    同时，switch是惰性求值，只有在需要求值时才去计算表达式，从而降低消耗，提升性能。
    在这里插入图片描述

    for循环：

    1.GO 的循环语句只有for ,没有while/do while
    2.for 语句后面同样不用加( )
    3.for语句的三个部分,省略任何一个时，分号不能省略
    4.只留条件判断时，可以不用分号 （相当于while语句）
    5.全部省略,变为无限循环

    //while:
for experssion {
    
}
//无限循环
for {
    if state {
        break
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    goto 可以跟标签更紧密合作，可以代替break 跳出多重循环

    手动实现排序

    手写实现的冒泡排序，Go代码如下所示：

    这里需要注意，切片作为参数传递是引用传递！

    func bubbleSort(nums []int){
    n:=len(nums)
    // 这里i是定义排序好的数量
    for i:=0;i<n-1;i++ {
        // 每次排序都是从第一个元素开始冒泡
        for j:=0;j<n-1-i;j++ {
            if nums[j]>nums[j+1] {
                nums[j+1],nums[j]=nums[j],nums[j+1]
            }
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    手写实现插入排序，Go代码如下所示：

    func insertSort(nums []int){
    n:=len(nums)
    // 从无序组第二个元素开始依次插入有序组中
    for i:=1;i<n;i++{
        key:=nums[i]
        j:=i-1
        for j>=0 && key<nums[j]{
            nums[j+1]=nums[j]
            j--
        }
        nums[j+1]=key
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    手动实现快速排序，具体Go代码如下

    func quickSort(nums []int){
    n:=len(nums)
    if n<2 {
        return 
    }
    // 定义基准线
    pivot:=nums[0]
    low,high:=0,n-1
    for low<=high {
        if nums[low]<=pivot{
            low++
        }else{
            nums[low],nums[high]=nums[high],nums[low]
            high--
        }
    }
    // 交换基准元素位置
    nums[0],nums[high]=nums[high],nums[0]
    // 递归排序左右子数组
    quickSort(nums[:high])
    quickSort(nums[high+1:])
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    3.基础数据类型及运算

    Go语言中基础数据类型有：整型、浮点型、复数、布尔型、字符型、字符串型以及错误类型

    可以用 reflect.TypeOf 函数来查看类型名称

    1.基础类型

    1.整型

    整型按照是否有符号可以分为：有符号位和无符号位；

    整型按照位数可以分为：int int8 int 16 int32 int32 int64

    这里需要注意：不同的整型之间是不能直接比较，不能直接运算

    2.浮点数

    浮点数主要包括float32和float64

    标准库math包中的函数都使用float64
    在这里插入图片描述

    3.复数

    复数由两个浮点数表示，一个实部、一个虚部

    有两种复数类型，即complex64（两个float32组成）和complex128（两个float64组成）

    有三个内置复数处理函数

    complex(float,float) 创建复数

    real() 获取实部

    image() 获取虚部

    package main

import (
	"fmt"
)

func main() {
	// 创建复数
	var comp1 complex64 = complex(2, 3)     // 实部为2，虚部为3
	comp2 := complex(4.5, 7.1)             // 使用默认类型complex128

	// 输出复数
	fmt.Println("Complex 1:", comp1)
	fmt.Println("Complex 2:", comp2)

	// 访问实部和虚部
	fmt.Println("Real part of Complex 1:", real(comp1))     // 输出实部
	fmt.Println("Imaginary part of Complex 1:", imag(comp1)) // 输出虚部
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    4.布尔类型

    布尔值主要包括true和false，类型长度为1byte

    布尔类型无法被其他类型赋值，也不支持类型转换

    这里布尔类型不支持用0和1表示真假

    if 和for 语句的条件部分必须是布尔类型的值或表达式

    2.运算符

    运算符主要包括算术运算符、关系运算符、逻辑运算符、赋值运算符以及位运算符

    1.算术运算符

    算术运算符主要包括加减乘除、取模、自增、自减

    **注意：**Go语言自增只支持变量++,不支持++变量，自减也是

    2.关系运算符

    关系运算符主要包括

    ==
!=
>
<
>=
<=

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    注意：由于布尔类型不支持转换整型，因此不等式连写，例如x

    3.逻辑运算符

    逻辑运算符主要包括取反！、且&&、或||

    4.赋值运算符

    在这里插入图片描述

    5.位运算符

    位运算符包括

    << 左移 相当于乘以2
>> 右移 相当于除以2
&  位与
|  位或
^ 异或

    • 1
    • 2
    • 3
    • 4
    • 5

    位运算只对整数其作用，是底层运算，效率较高！
    在这里插入图片描述

    4.集合数据类型

    Go语言中主要有三种类型的集合，分别是数组Array、切片Slice以及Map

    1.数组

    数组是同类元素的集合，数组变量声明后，其元素类型、数组长度均不可变

    数组声明：

    // 只声明未赋值H
var arr1 [5]int
// 直接赋值
arr2:=[3]int{1,2,3}
// 数组长度由初始化数量确定
arr3:=[...]int{1,2,3} //...不可省略
// 对含有下标的元素赋初值 其余元素保持零值
arr4:=[4]{0:99,3:100}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    数组复制：

    数组变量之间进行复制会拷贝整个数组（值拷贝）

    	a := [...]string{"USA", "China", "India", "Germany"}
    b := a 
    b[0] = "Singapore"
    fmt.Println("a is ", a)
    fmt.Println("b is ", b)   
    //a is [USA China India Germany]  
    //b is [Singapore China India Germany]

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    数组传参：

    与数组复制类型，只是实参拷贝一份给形参，函数调用结束则销毁，二者相互独立，传递大数组时效率较低！

    func changeLocal(num [5]int) {
    num[0] = 55
    fmt.Println("inside function ", num)
}

func main() {
    num := [...]int{5, 6, 7, 8, 8}
    fmt.Println("before passing to function ", num)
    changeLocal(num) //num is passed by value
    fmt.Println("after passing to function ", num)
}
//before passing to function  [5 6 7 8 8]  
//inside function  [55 6 7 8 8]  
//after passing to function  [5 6 7 8 8] 

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    数组遍历：

    数组遍历可以采用for循环遍历或range遍历

    // for循环
 	a := [...]float64{67.7, 89.8, 21, 78}
    for i := 0; i < len(a); i++ { 
        fmt.Printf("%d th element of a is %.2f\n", i, a[i])
    }
// range遍历
	a := [...]float64{67.7, 89.8, 21, 78}
    for i, v := range a { // 第一个参数为序号，第二个为变量
        fmt.Printf("%d the element of a is %.2f\n", i, v)
    }
    //0 the element of a is 67.70  
    //1 the element of a is 89.80  
    //2 the element of a is 21.00  
    //3 the element of a is 78.00


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    此外，range遍历的两个参数，如果只用一个会报错，可以用_占位符来表示只用一个参数

    多维数组：

    	a := [3][2]string{
        {"lion", "tiger"},
        {"cat", "dog"},
        {"pigeon", "peacock"}, //此处,不可忽略，否则报错
    }
    for _, v1 := range a {
        for _, v2 := range v1 {
            fmt.Printf("%s ", v2)
        }
        fmt.Printf("\n")
    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    2.切片

    由于数组的定长性和值拷贝限制其使用，因此提供切片使用，即提供长度可变的数组引用

    切片声明时不能给定底层数组大小，否则变成了数组声明，同时可以使用内置函数make来声明和初始化！

    切片是引用类型，不支持==运算

    创建切片：

    这里需要注意，如果创建切片时指定底层数组，一旦切片改变，底层数组元素也会发生改变，因为切片是对原数组的引用。因此，多个切片可以共享同一个底层数组。

    // 指定底层数组创建
 	a := [5]int{76, 77, 78, 79, 80}//底层数组
    s1 := a[0:4] // from a[0] to a[3]
    s2 := a[:4]  // from a[0] to a[3]
    s3 := a[2:5] // from a[2] to a[4]
    s4 := a[2:]  // from a[2] to a[4]
    fmt.Printf("%v\n%v\n%v\n%v", s1, s2, s3, s4)
    //[76 77 78 79]
    //[76 77 78 79]
    //[78 79 80]
    //[78 79 80]
// 同时创建数组和切片
//指定数组大小，只创建数组    
c := [3]int{6, 7, 8}
//不指定数组大小，返回切片引用，底层数组匿名 
d := []int{6, 7, 8}  
//用...推断数组大小，只创建数组 
e := [...]int{6, 7, 8} 

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    内置函数 len() 返回切片当前长度
    内置函数cap()返回切片底层数组容量

    切片动态增加：

    内置函数 append() 动态扩展切片，在底层数组容量范围内，会直接覆盖底层数组元素

    package main

import "fmt"

func main() {
    arr := [7]int{9, 8, 7, 6, 5, 4, 3}
    sli := arr[1:3]
    sli = append(sli, 20) // 增加一个20，切片容量扩展一倍
    fmt.Printf("%v\n", arr) //[9 8 7 20 5 4 3]
    fmt.Printf("%v\n", sli) //[8 7 20]
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    切片动态增加时，当超过底层数组容量大小时，会重新创建底层数组，并转移数据
    切片增长在元素小于1000时，成倍增长，超过1000，增长速率大概为1.25

    	cars := []string{"Ferrari", "Honda", "Ford"}
    fmt.Println("cars:", cars, "length", len(cars), "capacity", cap(cars))  
    //cars: [Ferrari Honda Ford] length 3 capacity 3
    fmt.Printf("%x\n", &cars[0])
    //c000080330
    cars = append(cars, "Toyota")
    fmt.Println("cars:", cars, "length", len(cars), "capacity", cap(cars))
    //cars: [Ferrari Honda Ford Toyota] length 4  capacity 6 //why 6
    fmt.Printf("%x\n", &cars[0])    
    //c0000a4000   //Why

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    切片合并：

    内置函数 append() 还支持切片的合并，用…运算符把对应切片所有元素都取出

    	veggies := []string{"potatoes", "tomatoes", "brinjal"}
    fruits := []string{"oranges", "apples"}
    food := append(veggies, fruits...) //... 不可忽略
    fmt.Println("food:", food)
    //food: [potatoes tomatoes brinjal oranges apples]


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    切片传参：

    在函数传参时，复制的是结构体拷贝，实现引用传递

    func subtactOne(numbers []int) {
    for i := range numbers {
        numbers[i] -= 2
    }
}
func main() {
    nos := []int{8, 7, 6}
    fmt.Println("slice before function call", nos)
    //slice before function call [8 7 6]
    subtactOne(nos)
    fmt.Println("slice after function call", nos)
    //slice after function call [6 5 4]
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    多维切片：

    多维切片比多维数组灵活，每行元素个数不必相同

     	pls := [][]string{
        {"C", "C++", "C#"},
        {"JavaScript"},
        {"Go", "Rust"},
    }
    for _, v1 := range pls {
        for _, v2 := range v1 {
            fmt.Printf("%s ", v2)
        }
        fmt.Printf("\n")
    }
    //C C++ C# 
    //JavaScript 
    //Go Rust 


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    3.Map

    Map用于存储一系列无序的键值对，是引用类型，不支持==运算（nil除外）

    Map不是线程安全的，不支持并发写

    1.初始化

    Map零值不可用，只声明不初始化为nil值，不分配底层存储空间，不能添加元素
    用字面量或make函数进行初始化后可以添加元素

    	var m1 map[string]int
    fmt.Println(m1 == nil)
    //true
    //m1["a"] = 1 //error

    m2 := map[string]int{}
    fmt.Println(m2 == nil)
    //false
    m2["a"] = 1 //ok

    m3 := make(map[string]int)
    fmt.Println(m3 == nil)
    //false
    m3["a"] = 1 //ok

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    2.赋值

    可在Map初始化后进行元素赋值，也可在Map初始化时直接元素赋值

    	personSalary := make(map[string]int)
    personSalary["steve"] = 12000
    personSalary["jamie"] = 15000
    personSalary["mike"] = 9000
    //初始化时，直接赋值
    personSalary := map[string]int{
        "steve": 12000,
        "jamie": 15000,
    }


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    3.元素查找

    Map元素通过下标访问其实可以返回两个值（底层实际为函数，Comma-ok 法）
    1.对应的value
    2.对应的key是否存在的布尔值

    	personSalary := map[string]int{
        "steve": 12000,
        "jamie": 15000,
    }
    value, ok := personSalary["joe"]
    if  ok  == true {
        fmt.Println("Salary of joe is", value)
    } else {
        fmt.Println("joe not found")
    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    4.Map元素遍历

    Map元素可以使用range 遍历，但不保证顺序

    	personSalary := map[string]int{
        "steve": 12000,
        "jamie": 15000,
    }
    personSalary["mike"] = 9000
    for key, value := range personSalary {
        fmt.Printf("personSalary[%s] = %d\n", key, value)
    }
    //personSalary[mike] = 9000
    //personSalary[steve] = 12000
    // personSalary[jamie] = 15000

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    5.Map元素删除

    使用内置函数delete()删除Map元素
    1.key存在，对应元素被删除
    2.key不存在，什么都不发生

    	personSalary := map[string]int{
        "steve": 12000,
        "jamie": 15000,
    }
    personSalary["mike"] = 9000
    fmt.Println("map before deletion", personSalary)
    delete(personSalary, "steve")
    fmt.Println("map after deletion", personSalary)
    //map before deletion map[jamie:15000 mike:9000 steve:12000]
    //map after deletion map[jamie:15000 mike:9000]

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    5.Go函数

    函数效率高则程序效率高，建议多用标准库函数

    1.函数定义

    //语法格式
func funcName(paramList)(resultList) {
	coding ……
}
//paramList = input1 type1,input2 type2 ……
//resultList = output1 type1,output2 type2 ……
//多个相邻相同类型参数可以使用简写
func add(a, b int) int {
    return a + b
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    Go函数中可以有多个返回值，同时返回值可以有变量名，并在函数体内可见。

    **注意：**不支持函数重载，因为重载只是偶尔有用，但在实践中会引起无解和导致脆弱性

    2.参数（不定参数）

    不定参数，形参数目可变、不确定
    不定参数声明语法格式： param … type

    不定参数的形参在函数内是切片

    func sum(nums ...int) int {
    total := 0
    for _, num := range nums {
        total += num
    }
    return total
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    上述不定参数是不定数量，但类型是相同的，如果要实现不定数量，同时不定类型，则需要通过接口类型interface{}作为参数实现

    func printAll(vals ...interface{}) {
    for _, val := range vals {
        fmt.Println(val)
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5

    3.匿名函数

    匿名函数相当于函数字面量，可以使用函数的地方就可以使用匿名函数

    //匿名函数直接调用
func(a,b int )int{
    return a-b
}(5,4)
//匿名函数赋值给函数变量
var sum = func(a,b int )int{
    return a+b
}
//函数作为返回值
func getFun(op string) func(a,b int )int {
    return func(a,b int )int{
        return a+b
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    4.闭包

    闭包=函数+引用环境，常见于在函数内部定义匿名函数，并且该匿名函数访问定义它的外部函数的作用域

    package main
import "fmt"
func main() {
    // 外部函数外的变量
    outsideVar := 10
    // 内部函数，形成闭包
    closureFunc := func() {
        fmt.Println(outsideVar) // 闭包函数内部访问外部变量
    }
    closureFunc() // 调用闭包函数
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    函数柯里化：

    函数柯里化就是把接收多个参数的函数变换成接收单一参数的函数

    函数柯里化是一种将多参数函数转换为一系列单参数函数的过程。这种转换的结果是，原始函数可以通过一系列较少参数的函数来调用。

    5.延迟调用（defer）

    Go函数支持defer进行延迟调用

    defer类似OOP语言异常处理中的final子句，常用来保证系统的资源的回收和释放。

    	defer Println("last")
    Println("main body")
    Println("first")
    //main body
    //first
    //last

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    使用defer函数时，会把当时的实参值传递给形参，即使后序实参发生变化也不影响函数结果！

    	a := 5
    defer fmt.Println(“defer 注册函数时的a值", a)
    a = 10
    fmt.Println(“普通函数的a值", a)
    //普通函数的a值 10
    //defer 注册函数时的a值 5

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    此外，使用多个defer时，这些defer调用以先进后出（FILO）顺序在函数返回前被执行！

        name := "Naveen"
    fmt.Printf("Original String: %s\n", string(name))
    fmt.Printf("Reversed String: ")
    for _, v := range []rune(name) {
        defer fmt.Printf("%c", v)
    }
    //Original String: Naveen
    //Reversed String: neevaN

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    6.递归函数

    形式上：一个正在执行的函数调用了自身(直接递归).

    递归不能无限制调用，因为栈空间有限
    递归中必须有完成终极任务的语句
    递归调用参数逐渐逼近结束条件
    递归的目的是简化设计使程序易读，但通常效率较低

    6.结构体和方法

    1.结构体

    1.结构体定义

    结构体把有内在联系的不同类型的数据统一成一个整体，使它们相互关联

    结构体是变量的集合，从外部看是一个实体

    type Employee struct{
    firstName string
    lastName  string
    age       int
    salary    int
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    2.带标签的结构体

    结构体中的字段除了名字和类型外，还可以有一个可选的标签（tag）

    标签是一个附属于字段的字符串，用于描述字段信息
    标签还可以按key1:“value1” key2:“value2”键值对进行修饰，来提供编码、解码、ORM等转化辅助

    可以使用反射，获取结构体标签中的每一个键值对

    package main

import (
	"fmt"
	"reflect"
)

type Person struct {
	Name string `json:"name" validate:"required"`
	Age  int    `json:"age" validate:"min=18"`
}

func main() {
	p := Person{Name: "Alice", Age: 25}
	// 获取结构体字段的标签信息
	t := reflect.TypeOf(p)
	for i := 0; i < t.NumField(); i++ {
		field := t.Field(i)
		fmt.Printf("Field: %s, Tag: %s\n", field.Name, field.Tag)
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    3.结构变量初始化

    1.可以使用字段名初始化，这样不需要按顺序，未指定的字段为零值

        emp1 := Employee{
        firstName: "Sam",
        age:       25,
        salary:    500,
        lastName:  “Anderson”, //逗号不能忽略
    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    2.用字面量初始化，按字段类型声明顺序并全部设置，顺序不对或遗漏字段报错

    emp2 := Employee{"Thomas", "Paul", 29, 800}

    • 1
    4.访问修改字段值

    1.采用 结构变量.字段

    emp := Employee{"Thomas", "Paul", 29, 800}
fmt.Println(emp.age)

    • 1
    • 2

    2.采用（*结构变量指针）.字段

    emp := &Employee{"Sam", "Anderson", 55, 6000}
fmt.Println("First Name:", (*emp).firstName)

    • 1
    • 2

    3.采用 结构变量指针.字段，不支持->

    emp := &Employee{"Sam", "Anderson", 55, 6000}
fmt.Println("First Name:", emp.firstName)

    • 1
    • 2
    4.匿名字段

    结构体字段也可以省略字段名，字段名默认为对应数据类型名称（数据类型不能重复）

    	type Person struct {
        string
        int
    }
    p := Person{"Naveen", 50}
    p.int =60

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    2.方法

    方法是对具体类型行为的封装，本质上是绑定到该类型的函数。

    OO语言的方法通常有个隐藏的this或self指针来指向对象，Go把这个隐藏指针暴露出来，称为接受者。

    func (t Type) funcName(paramList)(resultList)
func (t *Type) funcName(paramList)(resultList)

    • 1
    • 2
    1.方法实例
    type Employee struct {
    name     string
    salary   int
    currency string
}
//定义方法
func (e Employee) displaySalary() {
    fmt.Printf("Salary of %s is %s%d", e.name, e.currency, e.salary)
}
func main() {
    emp1 := Employee{
        name:     "Sam Adolf",
        salary:   5000,
        currency: "$",
    }
    emp1.displaySalary() 
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    其实方法可以使用等价的函数实现，具体如下所示：

    type Employee struct {  
    name     string
    salary   int
    currency string
}
func displaySalary(e Employee) {  
    fmt.Printf("Salary of %s is %s%d", e.name, e.currency, e.salary)
}
func main() {  
    emp1 := Employee{
        name:     "Sam Adolf",
        salary:   5000,
        currency: "$",
    }
    displaySalary(emp1)
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    既然函数可以做，那为什么还需要方法呢？

    在 Go 语言中，方法和等价的函数都能完成类似的工作。虽然它们可以完成相同的任务，但方法和函数之间存在一些差异和适用场景，其中方法更适合于特定类型的操作和面向对象的编程。

    GO 的函数不能重载，导致不同类型不能用同名函数，而不同类型的方法可以同名
    GO 不支持class ,使用结构代替类，结构字段用来封装对象属性，方法用来封装对象的行为

    此外，方法并非结构体专有，所有自定义类型都可以定义方法

    type myInt int //自定义类型

func (a *myInt) add(b myInt) myInt {
    return *a + b
}

num1 := myInt(5)
num2 := myInt(10)
sum := num1.add(num2)

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    7.接口

    Go语言中的接口是Duck模型的非侵入式接口，与传统的接口不同，非侵入式接口其具体类型实现接口不需要显式声明，只要其方法集是接口的超集，编译时会进行对应校验！

    GO 接口只有方法签名，没有数据字段，没有函数体代码

    类型的方法集是多个接口的超集，则实现多个接口

    1.接口类定义

    // 命令接口类型
type interfaceName interface{//接口类型命名通常以er为后缀
    methodName(paramList)(resultList)
    otherInterfaceName
}
// 匿名接口类型
interface{
    methodName(paramList)(resultList)
    otherInterfaceName
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    而如果匿名接口中方法集为空，即是interface{}是一种空接口，所有的类型都实现了空接口，都可以赋值或传递给空接口。

    2.接口初始化

    只声明未赋值的接口变量为nil
    接口变量初始化需要把接口绑定到具体类型实例
    未初始化的接口变量不能调用其方法
    方法的接收者才能给接口变量赋值
    接口变量的值包括底层类型的值和具体类型

    package main

import (
	"fmt"
)

// 接口定义
type Speaker interface {
	Speak() string
}

// 实现接口的结构体
type Dog struct{}

// Dog 结构体实现 Speak 方法
func (d Dog) Speak() string {
	return "Woof!"
}

// 创建接口的实例
func NewSpeaker() Speaker {
	return Dog{} // 返回一个 Dog 类型，它满足了 Speaker 接口
}

func main() {
	// 初始化接口并调用方法
	speaker := NewSpeaker()
	fmt.Println(speaker.Speak())
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29

    此外，一个接口可以包含一个或者多个接口，即嵌套接口

    type ReadWrite interface {
    Read(b Buffer) bool
    Write(b Buffer) bool
}
type File interface{
    ReadWrite
    close() bool
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    3.接口类型断言

    接口类型断言用来判断实现某个接口的变量是否为某个类型

    若是，则返回该类型的值和true

    不是，则返回该类型的零值和false

    // interfaceName.(typeName)
    var a interface{} = 56
    v, ok := a.(int)
    fmt.Println(v, ok)
    //56 true
    var b interface{} = true
    v, ok = b.(int)
    fmt.Println(v, ok)
    //0 false

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    4.接口类型查询

    接口类型查询是使用swtich语句确定接口变量底层类型

    .(type)只能用于switch表达式是因为变量底层类型判断只能用接口类型断言，go 只能判断变量内存格式是否匹配某种类型，并按某种类型来解析值

    func findType(i interface{}) {
    switch i.(type) {//.(type)只能用于switch表达式
    case string:
        fmt.Printf("string and value is %s\n", i.(string))
    case int:
        fmt.Printf("int and value is %d\n", i.(int))
    default:
        fmt.Printf("Unknown type\n")
    }
}
findType(77)
findType(89.98)
// int and value is 77 
// Unknown typ

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    5.Stringer接口

    Stringer 接口是 Go 语言中的一个接口，它只包含一个方法：String()，用于返回该类型的字符串表示形式。这个接口通常被用来自定义类型的字符串输出格式。

    在 Go 语言中，如果某个类型实现了 Stringer 接口，那么你可以使用 fmt 包中的打印方法（如 Println 或 Sprintf）来自定义该类型的输出方式。

    以下是 Stringer 接口的定义：

    type Stringer interface {
    String() string
}

    • 1
    • 2
    • 3

    接口的 String() 方法返回一个字符串。实现了 Stringer 接口的类型可以定义自己的 String() 方法，以便自定义该类型的字符串输出。

    以下是一个简单的示例，演示了如何使用 Stringer 接口：

    package main
import (
    "fmt"
)
type Person struct {
    Name string
    Age  int
}
// 实现 Stringer 接口
func (p Person) String() string {
    return fmt.Sprintf("%s is %d years old", p.Name, p.Age)
}
func main() {
    person := Person{"Alice", 30}
    fmt.Println(person) // 输出: Alice is 30 years old
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    在这个例子中，Person 类型实现了 Stringer 接口，重写了 String() 方法，这样当我们使用 fmt.Println 打印 Person 类型的变量时，会调用 String() 方法，并输出该类型的自定义字符串格式。

    总结，实现了Stringer接口的类型变量，使用fmt.Println方法打印该对象时，可以按照指定一定的格式输出，与Java中重写toString方法类似。

    6.Sorter接口

    标准库的sort包，定义排序要实现三个方法：

    //Len()   反映元素个数的方法
//Less(i, j)  比较第 i 和 j 个元素
//Swap(i, j) 交换第 i 和 j 个元素
// 具体Sorter接口定义如下
type Sorter interface {
    Len() int
    Less(i, j int) bool
    Swap(i, j int)
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    请基于Sorter接口实现冒泡排序：

    package main

import (
	"fmt"
)

type Sorter interface {
	Len() int
	Less(i, j int) bool
	Swap(i, j int)
}

type IntArray []int

func (arr IntArray) Len() int {
	return len(arr)
}

func (arr IntArray) Less(i, j int) bool {
	return arr[i] < arr[j]
}

func (arr IntArray) Swap(i, j int) {
	arr[i], arr[j] = arr[j], arr[i]
}

func BubbleSort(data Sorter) {
	n := data.Len()
	for i := 0; i < n-1; i++ {
		for j := 0; j < n-i-1; j++ {
			if data.Less(j+1, j) {
				data.Swap(j, j+1)
			}
		}
	}
}

func main() {
	array := IntArray{64, 34, 25, 12, 22, 11, 90}
	fmt.Println("Unsorted array:", array)

	BubbleSort(array)
	fmt.Println("Sorted array:", array)
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44

    7.接口特性

    接口特性简称动静结合

    接口静态特性：

    支持在编译阶段的类型检查：当一个接口类型变量被赋值时，编译器会检查右值的类型是否实现了该接口方法集合中的所有方法。

    接口动态特性：

    即：使用空接口变量可以使用不同类型的变量赋值

    在运行时存储在接口类型变量中的值的真实类型。比如：var i interface{} = 13中接口变量i的动态类型为int。
    在运行时可以被赋值为不同的动态类型变量，从而支持运行时多态。

    8.反射

    变量的最基本信息是类型和值，反射可以在程序运行时检查变量的类型和值

    通过反射可以获取结构体变量的各字段信息，甚至包括结构字段的tag信息

    package main
import (
	"fmt"
	"reflect"
)
type Person struct {
	Id   int //首字母大写表示公开字段
	Name string
	Sex  string
}
func (this Person) Call() {
	fmt.Println("我正在打电话")
}
func getTypeAndValue(object interface{}) {
	//动态获取对象object的类型信息
	objectType := reflect.TypeOf(object)
	objectValue := reflect.ValueOf(object)
	fmt.Println("type =", objectType.Name())
	fmt.Println("type =", objectType, "value =", objectValue)
	// objectType.NumField() 获取字段的总数
	for i := 0; i < objectType.NumField(); i++ {
		field := objectType.Field(i)
		value := objectValue.Field(i)
		fmt.Printf("type %d = %v\n", i, field.Type)
		fmt.Printf("name %d = %v\n", i, field.Name)
		fmt.Printf("value %d = %v\n", i, value.Interface())
	}
	for i := 0; i < objectValue.NumMethod(); i++ {
		method := objectValue.Method(i)
		method.Call(nil)
	}
}
func main() {
	person := Person{1, "nancy", "mail"}
	getTypeAndValue(person)
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36

    8.错误处理

    Go语言里没有异常机制，只有错误处理，错误通过函数的多返回值来处理

    Go语言的错误主要有：编译时错误、运行时错误以及逻辑错误

    Go语言的错误处理方式

    1.可处理，通过函数返回错误进行处理

    2.不可处理，通过panic抛出错误，退出程序

    1.error接口

    通过error 接口 实现错误处理的标准模式，打印错误时自动调用Error()函数

    type error interface{
    Error() string
}

    • 1
    • 2
    • 3

    可能出错的函数最后一个返回值为错误类型，检查该返回值是否为nil，是则处理错误，否则正常调用

     	f, err := os.Open("/test.txt")
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println(f.Name(), "opened successfully")

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    2.if快乐路径原则

    “快乐路径”原则是编程中的一种设计理念，其指导思想是使函数的主要路径尽可能保持“快乐”，也就是函数的主要工作或逻辑能够尽快完成，而不被意外情况干扰。

    一个例子就是通过合理的错误检查和返回，将错误处理逻辑放在函数的开头，而将主要逻辑和处理放在函数的主要部分。这样可以尽早退出函数并返回错误，但同时保持主要逻辑在函数主体内部，让主逻辑尽可能快乐。

    func PerformTask(param int) (result int, err error) {
    // 错误检查放在前面
    if param < 0 {
        return 0, errors.New("param cannot be negative")
    }

    // 主逻辑放在主体内部
    // 这里是函数的主要逻辑，称为快乐路径
    result = param * 2
    return result, nil
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    3.自定义错误

    error是Go语言内置的接口类型，只有一个方法Error()，用于返回错误信息的字符串表示。

    标准库中errors包提供了创建简单错误信息的函数。

    package main

import (
	"errors"
	"fmt"
)

func divide(a, b int) (int, error) {
	if b == 0 {
		return 0, errors.New("division by zero")
	}
	return a / b, nil
}

func main() {
	result, err := divide(6, 2)
	if err != nil {
		fmt.Println("Error:", err)
	} else {
		fmt.Println("Result:", result)
	}

	result, err = divide(3, 0)
	if err != nil {
		fmt.Println("Error:", err)
	} else {
		fmt.Println("Result:", result)
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29

    此外，还可以使用fmt包的Errorf 函数创建自定义错误！

    package main

import (
	"fmt"
)
func someFunction() error {
	return fmt.Errorf("This is a more detailed error: %s", "specific error message")
}

func main() {
	err := someFunction()
	if err != nil {
		fmt.Println("Error:", err)
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    当多处错误处理存在代码重复时，可以使用goto集中处理错误！

    err := firstCheckError()
if err != nil {
    goto onExit
}
err = secondCheckError()
if err != nil {
    goto onExit
}
// 正常处理代码
onExit:
fmt.Println(err)
exitProcess()

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    4.panic

    panic 是 Go 语言中的内建函数之一，用于在发生不可恢复的错误时引发程序中止。panic 会停止当前函数的执行，并向调用者传播一个引发恐慌的信号，随后程序将被终止。

    通常情况下，panic 用于处理严重错误，如数组越界、空指针引用等。当它被调用时，程序将停止执行当前函数，开始执行延迟（defer）函数，然后程序会崩溃，并显示 panic 产生的错误信息。 在遇到 panic 时，程序的正常流程会被打破，不会再继续执行当前任务。

    在开发过程中，尽量避免使用 panic，而应该在可以预测和处理的情况下使用错误返回（error returns）或其他适当的处理方式，因为 panic 不可恢复，容易引起程序不稳定。

    package main
import "fmt"
func someFunc() {
    // 模拟一个无法处理的错误
    err := someErrorOccurred()
    if err != nil {
        panic("An unexpected error occurred: " + err.Error())
    }
}
func main() {
    fmt.Println("Starting the program.")
    someFunc()
    fmt.Println("End of the program.")
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    在这里插入图片描述

    5.recover

    在 Go 语言中，recover 函数用于恢复程序的执行，从恐慌状态（panic）中恢复。recover 只有在延迟函数（defer）的内部调用时才会生效。

    通常情况下，recover 与 defer 配合使用，以便在程序进入恐慌状态时恢复程序执行。

    下面是一个使用 recover 来捕获并处理恐慌状态的示例：

    package main

import (
	"fmt"
)

func recoverDemo() {
	if r := recover(); r != nil {
		fmt.Println("Recovered:", r)
	}
}

func someFunc() {
	defer recoverDemo()

	// 模拟一个恐慌状态
	panic("Something went wrong!")
}

func main() {
	fmt.Println("Starting the program.")
	someFunc()
	fmt.Println("End of the program.")
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24

    在这个示例中，recoverDemo 函数作为一个延迟函数（defer）在 someFunc 中执行。当 someFunc 函数引发了恐慌状态，recoverDemo 中的 recover 函数捕获到这个恐慌，然后打印出了错误信息。

    请注意，recover 函数只在延迟函数中有效。在非延迟函数中调用 recover 是无效的，且只有在恐慌状态发生时才能捕获错误信息。

    9.并发

    1.进程、线程、协程

    进程是程序在内存中运行时，操作系统对其进行资源分配和调度的独立单位
    线程是进程的一个执行实体，是进程内部进行的一条执行路径，是 CPU 调度和分派的基本单位，它是比进程更小的能独立运行的基本单位
    每个进程至少包括一个线程，每个进程的初始线程被称为主线程，主线程终止，进程终止
    协程是轻量级的线程，一个线程可以拥有多个协程
    进程和线程是操作系统级的，协程是编译器级的。协程不被操作系统内核管理，而完全由程序控制，因此没有线程切换的开销。和多线程比，数量越多，协程的性能优势就越明显。协程的最大优势在于其轻量级，可以轻松创建上万个而不会导致系统资源衰竭

    2.goroutine

    在Go语言中，Goroutine是并发执行的基本单元。它们是Go运行时环境中的轻量级线程，由Go调度器分配到逻辑处理器上执行。Goroutine的运行并不依赖于物理处理器或操作系统线程。每个逻辑处理器（P）负责运行Goroutine，多个P可以运行在一个物理处理器（CPU）上。

    3.协程通信

    不要通过共享内存来通信，而是通过通信来共享内存

    协程间的通信常见是两种方式：

    1.共享数据：很多语言采用共享内存来实现程序数据同步，确保程序以合乎逻辑的方式执行。在程序执行过程中，进程或线程可能对共享数据加锁，以禁止其他进程或线程修改它。总体编程复杂性高

    2.消息机制：每个并发单元是独立个体，多个并发单元的数据不共享，通过消息通信来同步数据。

    4.channel通道

    通道是一种特殊的类型，同时只能有一个 goroutine 访问通道进行发送和获取数据。

    通道写入和读取使用 <- 运算符
    写入 ：通道<-变量
    读取： 变量<-通道

    5.缓冲通道

    通道包括无缓冲通道和有缓冲通道
    无缓冲通道 make(chan datatype)
    有缓冲通道 make(chan datatype，capacity)

    无缓冲通道只能存储一条消息，有缓冲通道可以根据make函数的capacity参数存储n条消息，按FIFO读出

    func receiver(c chan string) {
    for msg := range c {
        fmt.Println(msg)
    }
}
func main() {
    messages := make(chan string, 2)
    messages <- "hello"
    messages <- "world"
    go receiver(messages)   
    time.Sleep(time.Second * 1)
}//hello world	

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    此外，还能使用内置函数返回缓冲通道状态

    ​ len()获取通道当前缓存数
    ​ cap()获取通道缓存容量

        ch := make(chan string, 3)
    ch <- "naveen"
    ch <- "paul"
    fmt.Println("capacity is", cap(ch))
    fmt.Println("length is", len(ch))
    fmt.Println("read value", <-ch)
    fmt.Println("new length is", len(ch))
    //capacity is 3
    //length is 2
    //read value naveen
    //new length is 1

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    无缓冲通道，写入等待读取，读取等待写入，在双方准备好之前是阻塞的

    有缓冲通道，通道已满时的写入会等待，通道已空的读取会等待

    6.关闭通道

    关闭通道使用内置函数close(),实际上是关闭写入，即发送者告诉接收者不会再有数据发往通道

    接收者能够在通道接收数据的同时，获取通道是否已关闭的参数 。

    func producer(chnl chan int) {  
    for i := 0; i < 10; i++ {
        chnl <- i
    }
    close(chnl)
}
func main() {  
    ch := make(chan int)
    go producer(ch)
    for {
        v, ok := <-ch
        if ok == false {
            break
        }
        fmt.Println("Received ", v, ok)
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    此外，for range能够自动判断通道是否关闭，具体代码如下所示：

    func producer(chnl chan int) {  
    for i := 0; i < 10; i++ {
        chnl <- i
    }
    close(chnl)
}
func main() {  
    ch := make(chan int)
    go producer(ch)
    for v := range ch {
        fmt.Println("Received ",v)
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    7.WaitGroup

    sync.WaitGroup 用于等待一组 Go 协程执行完成后再执行主程序的方法。它提供了一个简单的机制，以便主程序知道其他所有协程何时执行完成。

    在使用 sync.WaitGroup 时，主要有三个函数：

    • Add(int)：增加要等待的协程数量。
    • Done()：标志已完成的协程。
    • Wait()：等待所有的协程都完成。

    通常，Add 函数用于计数要等待的协程数量，然后在协程的函数中使用 Done 标志已经执行完毕，最后使用 Wait 阻塞主程序，直到所有协程都执行完毕。

    image-20231107161709866

    以下是一个示例，演示了 sync.WaitGroup 的用法：

    package main

import (
	"fmt"
	"sync"
	"time"
)

func worker(id int, wg *sync.WaitGroup) {
	defer wg.Done() // 标志协程完成
	fmt.Printf("Worker %d starting\n", id)
	time.Sleep(time.Second) // 模拟工作
	fmt.Printf("Worker %d done\n", id)
}

func main() {
	var wg sync.WaitGroup

	for i := 1; i <= 5; i++ {
		wg.Add(1) // 增加等待的协程数量
		go worker(i, &wg)
	}

	wg.Wait() // 等待协程执行完成
	fmt.Println("All workers have finished")
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26

    在这个示例中，我们启动了五个协程，每个协程模拟一些工作（通过 time.Sleep 模拟）。Add 用于增加要等待的协程数量，Done 标志协程已执行完成，而 Wait 阻塞了主程序直到所有的协程都执行完毕。

    8.猜数字例题

    这里分享一道使用协程的例题，具体例题如下：感兴趣的小伙伴可以尝试一下
    在这里插入图片描述

    9.计时器Timer

    协程间的通信需设置超时等辅助机制

    一次性计时器：定时器只计时一次，结束便停止

    package main

import (
	"fmt"
	"time"
)

func main() {
	timer1 := time.NewTimer(2 * time.Second)

	<-timer1.C // 阻塞等待定时器信号
	fmt.Println("Timer 1 expired")

	timer2 := time.NewTimer(1 * time.Second)
	go func() {
		<-timer2.C
		fmt.Println("Timer 2 expired")
	}()

	stop2 := timer2.Stop() // 停止定时器2
	if stop2 {
		fmt.Println("Timer 2 stopped")
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24

    在这里插入图片描述

    10.定时器Ticker

    周期性定时器：定时器周期性进行计时，除非主动停止，否则将永久运行

    在Go语言中，time.Ticker 是用于重复间隔性触发操作的工具。与 time.Timer 不同，time.Ticker 会在一定的时间间隔内重复向通道发送时间事件。

    主要方法如下所示：

    func NewTicker(d Duration) *Ticker 指定一个时间创建一个Ticker ， Ticker一经创建便开始计时，不需要额外的启动命令
func (t *Ticker) Stop() 停止计时，但管道不会被关闭

    • 1
    • 2

    示例代码如下所示：

    package main

import (
	"fmt"
	"time"
)

func main() {
	ticker := time.NewTicker(1 * time.Second)
	defer ticker.Stop()

	for {
		select {
		case <-ticker.C:
			fmt.Println("Ticker ticked")
		}
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    11.select

    多路复用是在一个信道上传输多路信号或数据流，比如网线

    select 借用网络多路复用的概念，用于监听多个通道，同时响应多个通道

    多个通道都没有可写或可读的状态，select 会阻塞
    有一个通道是可写或可读的， select 会执行该通道语句
    有多个通道是可写或可读的， select 会随机选择其中一个执行

    select 语句是 Go 语言用于处理通道操作的关键工具。它可以同时监听多个通道操作，一旦某个通道可操作（有消息可以接收或发送），就执行相应的 case 语句。select 语句有点类似于 switch 语句，但是专门用于通道的操作。

    下面是一个示例，演示了 select 语句的用法：

    package main

import (
	"fmt"
	"time"
)

func main() {
	ch1 := make(chan string)
	ch2 := make(chan string)

	go func() {
		time.Sleep(2 * time.Second)
		ch1 <- "one"
	}()

	go func() {
		time.Sleep(1 * time.Second)
		ch2 <- "two"
	}()

	for i := 0; i < 2; i++ {
		select {
		case msg1 := <-ch1:
			fmt.Println("Received", msg1)
		case msg2 := <-ch2:
			fmt.Println("Received", msg2)
		}
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30

    在这个示例中，通过两个协程向两个不同的通道 ch1 和 ch2 发送消息。select 语句会监听这两个通道的状态，一旦有数据可接收，就执行相应的 case 语句，最终输出接收到的消息。

    12.Mutex

    多个线程同时竞争使用某个变量可能会导致结果失控

    mutex，互斥锁，用来保证某个变量在任一时刻，只能有一个线程访问；mutex 用Lock()和Unlock()来创建资源的临界区，这一区间内的代码是线程安全的，任何一个时间点都只能有一个goroutine执行这段区间的代码

    mutex 也可以用通道来代替，通道底层基于mutex，即mutex性能更高，通常不涉及线程交互数据的用mutex，其他性能要求不敏感用通道

    package main

import (
	"fmt"
	"sync"
)

var count = 0
var mutex sync.Mutex

func increment() {
	mutex.Lock()         // 通过 Lock() 方法锁住共享资源
	count++
	mutex.Unlock()       // 通过 Unlock() 方法解锁共享资源
}

func main() {
	var wg sync.WaitGroup

	for i := 0; i < 1000; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			increment()
		}()
	}

	wg.Wait()

	fmt.Println("Count:", count)
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31

    13.RWMutex

    Mutex 在大量并发时，同一时刻只有一个协程持有锁，其他阻塞等待，性能下降
    RWMutex在Mutex的基础之上增加了读、写的信号量，并使用了类似引用计数的读锁数量，可使多个协程持有读锁，适合应用在具有一定并发量且读多写少的场合。

    注意：

    RWMutex中可以申请多个读锁，有读锁时申请写锁将会被阻塞

    只要有写锁，后序申请读锁和写锁都会被阻塞

    主要方法如下：

    func (rw *RWMutex) Lock() //申请写锁
func (rw *RWMutex) Unlock() //释放写锁
func (rw *RWMutex) RLock() //申请读锁
func (rw *RWMutex) RUnlock()//释放读锁

    • 1
    • 2
    • 3
    • 4
    package main
import (
	"fmt"
	"sync"
)

var sharedData int
var rwMutex sync.RWMutex

func readData() {
	rwMutex.RLock() // 读取共享资源时使用 RLock() 方法
	defer rwMutex.RUnlock()
	fmt.Println("Read Data:", sharedData)
}

func writeData(value int) {
	rwMutex.Lock() // 写入共享资源时使用 Lock() 方法
	defer rwMutex.Unlock()
	sharedData = value
	fmt.Println("Write Data:", value)
}

func main() {
	// 读取数据
	for i := 0; i < 5; i++ {
		go readData()
	}

	// 写入数据
	for i := 0; i < 5; i++ {
		go writeData(i)
	}

	// 等待所有协程执行完毕
	fmt.Scanln()
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
  • 相关阅读:
    pip install torch
    string格式显示
    [附源码]JAVA毕业设计课程答疑系统（系统+LW）
    Hash Table Mock
    python与其他编程语言的区别
    常见开发、测试模型
    【五、Ubuntu移植WiringPi库】
    [leecode]快速排序
    这个选择，是一笔划算的投资
    以太网PHY芯片LAN8720A芯片研究
  • 原文地址：https://blog.csdn.net/qq_51447436/article/details/134295134