Go 语言快速学习总结

使用 Homebrew 安装：如果您使用 Homebrew 包管理器，这是最方便的方法。

brew install go

（二）IDE 选择说明

推荐使用 GoLand 或其他支持 Go 的 IDE，直接官网下载即可。

三、Go 语言程序学习

创建自己的工程目录，新建 src 目录。

（一）第一个 Go 语言编写

src 目录下创建 chapter1/hello 目录，新建 hello.go 文件，编写代码如下：

package main
import (
	"fmt"
	"os"
)

func main() {
	if len(os.Args) > 1 {
		fmt.Println("Hello World", os.Args[1])
	}
}

在该目录下执行 go run hello.go ZYF，运行结果为 Hello World ZYF。

（二）基本程序结构编写学习

1. 变量

前提：chapter2 目录下创建 variables，学习总结如下：

• 变量声明：使用 var 关键字声明一个变量，例如：var x int。
• 类型推断：可以使用 := 操作符进行变量声明和赋值，Go 会根据右侧的值自动推断变量类型。
• 变量赋值：使用赋值操作符 = 给变量赋值。
• 多变量声明：可以同时声明多个变量。
• 零值：未初始化的变量会被赋予零值。

新建 fib_test.go，简单实用斐波那契数列进行练习：

package variables
import "testing"

func TestFibList(t *testing.T) {
	a := 1
	b := 1
	t.Log(a)
	for i := 0; i < 5; i++ {
		t.Log(" ", b)
		tmp := a
		a = b
		b = tmp + a
	}
}

func TestExchange(t *testing.T) {
	a := 1
	b := 2
	a, b = b, a
	t.Log(a, b)
}

2. 常量

前提：chapter2 目录下创建 constant，学习总结如下：

• 常量声明：使用 const 关键字声明一个常量。
• 枚举常量：可以使用一组常量来模拟枚举。

新建 constant_test.go：

package constant
import "testing"

const (
	Monday = 1 + iota
	Tuesday
	Wednesday
)

const (
	Readable = 1 << iota
	Writable
	Executable
)

func TestConstant1(t *testing.T) {
	t.Log(Monday, Tuesday)
}

func TestConstant2(t *testing.T) {
	a := 1
	t.Log(a&Readable == Readable, a&Writable == Writable, a&Executable == Executable)
}

3. 数据类型

前提：chapter2 目录下创建 type，学习总结如下：

• 整数类型：int, int8, int16, int32, int64 等。
• 浮点数类型：float32, float64。
• 布尔类型：bool。
• 字符串类型：string。
• 数组类型：Array Types。
• 切片类型：Slice Types。
• 映射类型：Map Types。
• 结构体类型：Struct Types。
• 接口类型：Interface Types。
• 函数类型：Function Types。
• 通道类型：Channel Types。
• 指针类型：Pointer Types。

具体代码展开分析：

package main
import "fmt"

type Person struct {
	FirstName string
	LastName  string
	Age       int
}

type Shape interface {
	Area() float64
}

type Circle struct {
	Radius float64
}

func (c Circle) Area() float64 {
	return 3.14 * c.Radius * c.Radius
}

func add(a, b int) int {
	return a + b
}

type Operation func(int, int) int

func main() {
	// 演示多种数据类型
	fmt.Println("整数类型")
	var x int = 10
	var y int64 = 100
	fmt.Println(x, y)

	fmt.Println("浮点数类型")
	var a float32 = 3.14
	var b float64 = 3.14159265359
	fmt.Println(a, b)

	fmt.Println("布尔类型")
	var isTrue bool = true
	fmt.Println(isTrue)

	fmt.Println("字符串类型")
	str1 := "Hello, "
	str2 := "Go!"
	concatenated := str1 + str2
	fmt.Println(concatenated)

	fmt.Println("切片类型")
	numbers := []int{1, 2, 3, 4, 5}
	fmt.Println(numbers)

	fmt.Println("映射类型")
	ages := map[string]int{
		"Alice": 25,
		"Bob":   30,
	}
	fmt.Println(ages)

	fmt.Println("结构体类型")
	person := Person{
		FirstName: "John",
		LastName:  "Doe",
		Age:       30,
	}
	fmt.Println(person)

	fmt.Println("接口类型")
	var shape Shape
	circle := Circle{Radius: 5}
	shape = circle
	fmt.Println("Circle Area:", shape.Area())

	fmt.Println("函数类型")
	var op Operation
	op = add
	result := op(10, 5)
	fmt.Println("Addition:", result)

	fmt.Println("通道类型")
	messages := make(chan string)
	go func() {
		messages <- "Hello, Go!"
	}()
	msg := <-messages
	fmt.Println(msg)

	fmt.Println("指针类型")
	x = 10
	var ptr *int
	ptr = &x
	fmt.Println("Value of x:", x)
	fmt.Println("Value stored in pointer:", *ptr)
	*ptr = 20
	fmt.Println("Updated value of x:", x)
}

Go 语言中类型转换说明

Go 语言支持类型转换，但需要注意一些规则和限制。例如：

package main
import "fmt"

func main() {
	// 显式类型转换
	var x int = 10
	var y float64 = float64(x)
	fmt.Println(y)

	// 类型别名的转换
	type Celsius float64
	type Fahrenheit float64
	c := Celsius(25)
	f := Fahrenheit(c*9/5 + 32)
	fmt.Println(f)
}

4. 运算符

前提：chapter2 目录下创建 operator，学习总结如下：

• 算术运算符：+, -, *, /, %
• 逻辑运算符：&&, ||, !
• 比较运算符：==, !=, <, >, <=, >=
• 位运算符：&, |, ^, <<, >>, &^

新建 operator_test.go：

package operator
import (
	"fmt"
	"testing"
)

const (
	Readable = 1 << iota
	Writable
	Executable
)

func TestOperatorBasic(t *testing.T) {
	a := 10
	b := 5
	fmt.Println("Sum:", a+b)
	fmt.Println("Difference:", a-b)
	fmt.Println("Product:", a*b)
	fmt.Println("Quotient:", a/b)
	fmt.Println("Remainder:", a%b)

	x := true
	y := false
	fmt.Println("AND:", x && y)
	fmt.Println("OR:", x || y)
	fmt.Println("NOT:", !x)

	fmt.Println("Equal:", a == b)
	fmt.Println("Not Equal:", a != b)
	fmt.Println("Greater Than:", a > b)
}

func TestBitClear(t *testing.T) {
	a := 7 // 0111
	a = a &^ Readable
	a = a &^ Executable
	t.Log(a&Readable == Readable, a&Writable == Writable, a&Executable == Executable)
}

按位清除运算符 &^

在 Go 语言中，&^ 是按位清除运算符（Bit Clear Operator）。它用于将某些位置上的位清零。

func TestOther(t *testing.T) {
	var a uint8 = 0b11001100 // 十进制为 204
	var b uint8 = 0b00110011 // 十进制为 51
	result := a &^ b
	fmt.Printf("a: %08b\n", a)
	fmt.Printf("b: %08b\n", b)
	fmt.Printf("Result: %08b\n", result) // 输出：11000000
	fmt.Println("Result (Decimal):", result) // 输出：192
}

5. 条件语句（Conditional Statements）

前提：chapter2 目录下创建 condition，学习总结如下：

• if 语句：基于条件来决定是否执行某段代码。
• switch 语句：基于表达式的不同值执行不同的代码分支，无需 break。

创建 condition_test.go：

package condition
import (
	"fmt"
	"testing"
)

func TestConditionIf(t *testing.T) {
	age := 18
	if age < 18 {
		fmt.Println("You are a minor.")
	} else if age >= 18 && age < 60 {
		fmt.Println("You are an adult.")
	} else {
		fmt.Println("You are a senior citizen.")
	}
}

func TestConditionSwitch(t *testing.T) {
	dayOfWeek := 3
	switch dayOfWeek {
	case 1:
		fmt.Println("Monday")
	case 2:
		fmt.Println("Tuesday")
	case 3:
		fmt.Println("Wednesday")
	default:
		fmt.Println("Weekend")
	}
}

6. 循环语句（Loop Statements）

前提：chapter2 目录下创建 loop，学习总结如下：

• for 循环：支持初始化语句、循环条件和循环后的语句。
• range 循环：用于迭代数组、切片、映射、字符串等可迭代的数据结构。

创建 loop_test.go：

package loop
import (
	"fmt"
	"testing"
)

func TestLoopFor(t *testing.T) {
	for i := 1; i <= 5; i++ {
		fmt.Println("Iteration:", i)
	}
}

func TestLoopForRange(t *testing.T) {
	numbers := []int{1, 2, 3, 4, 5}
	for index, value := range numbers {
		fmt.Printf("Index: %d, Value: %d\n", index, value)
	}
}

func TestLoopForUnLimit(t *testing.T) {
	i := 1
	for {
		fmt.Println("Iteration:", i)
		i++
		if i > 5 {
			break
		}
	}
}

7. 跳转语句（Jump Statements）

前提：chapter2 目录下创建 jump，学习总结如下：

• break：跳出循环。
• continue：跳过本次循环迭代。
• goto：跳转到指定标签处（不推荐使用）。

创建 jump_test.go：

package jump
import (
	"fmt"
	"testing"
)

func TestJumpBreak(t *testing.T) {
	for i := 1; i <= 5; i++ {
		if i == 3 {
			break
		}
		fmt.Println("Iteration:", i)
	}
}

func TestJumpContinue(t *testing.T) {
	for i := 1; i <= 5; i++ {
		if i == 3 {
			continue
		}
		fmt.Println("Iteration:", i)
	}
}

（三）常用集合和字符串

src 目录下创建 chapter3，在 Go 语言中，集合是存储一组值的数据结构。常用的集合类型包括数组、切片、映射和通道。

1. 数组

前提：chapter3 目录下创建 array，学习总结如下：

• 数组的长度在声明时指定，且在创建后不可更改。
• 数组是值类型，当数组被赋值给新变量或作为参数传递时，会创建一个新的副本。

创建 array_test.go：

package array
import "testing"

func TestArrayInit(t *testing.T) {
	var arr [3]int
	arr1 := [4]int{1, 2, 3, 4}
	arr3 := [...]int{1, 3, 4, 5}
	arr1[1] = 5
	t.Log(arr[1], arr[2])
	t.Log(arr1, arr3)
}

func TestArrayTravel(t *testing.T) {
	arr3 := [...]int{1, 3, 4, 5}
	for _, e := range arr3 {
		t.Log(e)
	}
}

2. 切片

前提：chapter3 目录下创建 slice，学习总结如下：

• 切片是引用类型，它不保存数据，只是引用底层数组的一部分。
• 切片是动态长度的，可以根据需要进行扩容或缩减。

创建 slice_test.go：

package slice
import (
	"fmt"
	"testing"
)

func TestSlice(t *testing.T) {
	numbers := []int{1, 2, 3, 4, 5}
	fmt.Println("Original Slice:", numbers)

	slice := make([]int, 3)
	fmt.Println("Initial Make Slice:", slice)

	slice = append(slice, 10)
	slice = append(slice, 20, 30)
	fmt.Println("After Append:", slice)

	copySlice := make([]int, len(slice))
	copy(copySlice, slice)
	fmt.Println("Copied Slice:", copySlice)

	subSlice := numbers[1:3]
	fmt.Println("Subslice:", subSlice)

	subSlice[0] = 100
	fmt.Println("Modified Subslice:", subSlice)
	fmt.Println("Original Slice:", numbers)
}

3. Map

前提：chapter3 目录下创建 map，学习总结如下：

• 映射是键值对的无序集合。
• 键可以是任何可比较的类型，值可以是任意类型。

创建 map_test.go：

package my_map
import (
	"fmt"
	"testing"
)

func TestBasic(t *testing.T) {
	ages := map[string]int{
		"Alice": 25,
		"Bob":   30,
		"Eve":   28,
	}
	fmt.Println("Original Map:", ages)

	ages["Charlie"] = 35
	fmt.Println("After Adding:", ages)

	delete(ages, "Eve")
	fmt.Println("After Deletion:", ages)

	age, exists := ages["Alice"]
	if exists {
		fmt.Println("Alice's Age:", age)
	}
}

4. 实现 Set

前提：chapter3 目录下创建 set，学习总结如下：

• 使用切片：适用于小型集合。
• 使用映射：查找复杂度为 O(1)，适用于大型集合。
• 使用第三方库：如 github.com/deckarep/golang-set。

5. 字符串

前提：chapter3 目录下创建 string，学习总结如下：

• 字符串是不可变的。
• 可以使用双引号或反引号声明。
• 支持 UTF-8 编码。

创建 string_test.go：

package string
import (
	"strconv"
	"strings"
	"testing"
)

func TestString(t *testing.T) {
	var s string
	t.Log(s)
	s = "hello"
	t.Log(len(s))
	s = "中"
	t.Log(len(s))
	c := []rune(s)
	t.Logf("中 unicode %x", c[0])
}

func TestStringFn(t *testing.T) {
	s := "A,B,C"
	parts := strings.Split(s, ",")
	for _, part := range parts {
		t.Log(part)
	}
	t.Log(strings.Join(parts, "-"))
}

（四）函数

src 目录下创建 chapter4，在 Go 语言中，函数是一种用于执行特定任务的代码块。

1. 函数的声明

func functionName(parameters) returnType {
	// 函数体
	return returnValue
}

2. 函数参数

func greet(name string) {
	fmt.Printf("Hello, %s!\n", name)
}

3. 多返回值

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

4. 命名返回值

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

5. 可变数量的参数

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

6. 函数作为参数

func applyFunction(fn func(int, int) int, a, b int) int {
	return fn(a, b)
}

7. 匿名函数和闭包

func main() {
	x := 5
	fn := func() {
		fmt.Println(x)
	}
	fn()
}

8. defer 语句

func main() {
	defer fmt.Println("World")
	fmt.Println("Hello")
}

验证一：基本使用用例验证

在 chapter4 下新建 basic，在创建 func_basic_test.go：

package basic
import (
	"errors"
	"fmt"
	"testing"
)

func greet(name string) {
	fmt.Printf("Hello, %s!\n", name)
}

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

func TestBasic(t *testing.T) {
	greet("Alice")
	q, err := divide(10, 2)
	if err != nil {
		fmt.Println("Error:", err)
	} else {
		fmt.Println("Quotient:", q)
	}
	total := sum(1, 2, 3, 4, 5)
	fmt.Println("Sum:", total)
}

验证二：业务小举例

在 chapter4 下新建 biz，在创建 func_biz_test.go：

package biz
import (
	"fmt"
	"testing"
)

type Product struct {
	Name  string
	Price float64
}

func calculateTotal(products []Product) float64 {
	total := 0.0
	for _, p := range products {
		total += p.Price
	}
	return total
}

func applyDiscount(amount, discount float64) float64 {
	return amount * (1 - discount)
}

func TestBiz(t *testing.T) {
	products := []Product{
		{Name: "Product A", Price: 10.0},
		{Name: "Product B", Price: 20.0},
		{Name: "Product C", Price: 30.0},
	}
	total := calculateTotal(products)
	fmt.Printf("Total before discount: $%.2f\n", total)
	discountedTotal := applyDiscount(total, 0.1)
	fmt.Printf("Total after 10%% discount: $%.2f\n", discountedTotal)
}

（五）面向对象编程

src 目录下创建 chapter5，Go 语言支持面向对象编程（OOP），尽管与一些传统的面向对象编程语言相比，Go 的实现方式略有不同。在 Go 语言中，没有类的概念，但可以通过结构体和方法来实现面向对象的特性。

1. 结构体定义

创建 struct 目录，编写 struct_test.go：

package _struct
import (
	"fmt"
	"testing"
)

type Person struct {
	FirstName string
	LastName  string
	Age       int
}

func TestStruct(t *testing.T) {
	person1 := Person{
		FirstName: "Alice",
		LastName:  "Smith",
		Age:       25,
	}
	fmt.Println("First Name:", person1.FirstName)
	fmt.Println("Last Name:", person1.LastName)
	fmt.Println("Age:", person1.Age)
}

2. 实例创建及初始化

• 字面量初始化：使用花括号 {}。
• 部分字段初始化：省略其他字段。
• 使用 new 函数：返回指向结构体的指针。

3. 行为（方法）定义

创建 method 目录：

package method
import (
	"fmt"
	"testing"
)

type Circle struct {
	Radius float64
}

func (c Circle) Area() float64 {
	return 3.14159 * c.Radius * c.Radius
}

func TestMethodDef(t *testing.T) {
	c := Circle{Radius: 5}
	area := c.Area()
	fmt.Printf("Circle area: %.2f\n", area)
}

指针接收者

package method
import (
	"fmt"
	"testing"
)

type Counter struct {
	Count int
}

func (c *Counter) Increment() {
	c.Count++
}

func TestMethonRec(t *testing.T) {
	counter := Counter{Count: 0}
	counter.Increment()
	fmt.Println("Count:", counter.Count)
}

4. 接口定义使用

创建 interface 目录：

package interface_test
import (
	"fmt"
	"testing"
)

type Shape interface {
	Area() float64
}

type Circle struct {
	Radius float64
}

func (c Circle) Area() float64 {
	return 3.14159 * c.Radius * c.Radius
}

type Rectangle struct {
	Width  float64
	Height float64
}

func (r Rectangle) Area() float64 {
	return r.Width * r.Height
}

func TestInterface(t *testing.T) {
	shapes := []Shape{
		Circle{Radius: 2},
		Rectangle{Width: 3, Height: 4},
	}
	for _, shape := range shapes {
		fmt.Printf("Area of %T: %.2f\n", shape, shape.Area())
	}
}

5. 扩展和复用

• 组合和嵌套：允许你将一个结构体类型嵌套在另一个结构体类型中。
• 接口实现：通过接口实现多态性。
• 匿名字段和方法重用：继承另一个结构体的字段和方法。

6. 空接口和断言

• 空接口：interface{}，可以表示任何类型的值。
• 断言：value.(Type)，用于恢复具体类型。

package emptyassert
import (
	"fmt"
	"testing"
)

func DoSomething(p interface{}) {
	switch v := p.(type) {
	case int:
		fmt.Println("Integer", v)
	case string:
		fmt.Println("String", v)
	default:
		fmt.Println("Unknow Type")
	}
}

func TestEmptyAssert(t *testing.T) {
	var x interface{} = "hello"
	str, ok := x.(string)
	if ok {
		fmt.Println("String:", str)
	} else {
		fmt.Println("Not a string")
	}
}

7. GO 接口最佳实践

• 小接口与大接口：尽量设计小接口。
• 基于使用场景设计接口：思考在你的应用程序中如何使用接口。
• 使用合适的命名：使其能够表达出其用途和功能。

（六）编写好错误机制

src 目录下创建 chapter6，Go 语言中的错误处理机制是通过返回错误值来实现的。

1. 基本使用介绍

package basic
import (
	"errors"
	"fmt"
	"testing"
)

var LessThanTwoError = errors.New("n should be not less than 2")

func GetFibonacci(n int) ([]int, error) {
	if n < 2 {
		return nil, LessThanTwoError
	}
	fibList := []int{1, 1}
	for i := 2; i < n; i++ {
		fibList = append(fibList, fibList[i-2]+fibList[i-1])
	}
	return fibList, nil
}

func TestGetFibonacci(t *testing.T) {
	if v, err := GetFibonacci(1); err != nil {
		t.Error(err)
	} else {
		t.Log(v)
	}
}

2. 错误链

package chain
import (
	"errors"
	"fmt"
	"testing"
)

type FileError struct {
	Op   string
	Path string
	Err  error
}

func (e *FileError) Error() string {
	return fmt.Sprintf("%s %s: %v", e.Op, e.Path, e.Err)
}

func ReadFile(path string) ([]byte, error) {
	return nil, &FileError{Op: "read", Path: path, Err: errors.New("file not found")}
}

func TestChain(t *testing.T) {
	filePath := "/path/to/nonexistent/file.txt"
	_, err := ReadFile(filePath)
	if err != nil {
		fmt.Println("Error:", err)
		if fileErr, ok := err.(*FileError); ok {
			fmt.Printf("Operation: %s\n", fileErr.Op)
			fmt.Printf("File Path: %s\n", fileErr.Path)
		}
	}
}

3. Panic 和 Recover

package recover
import (
	"fmt"
	"testing"
)

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

func TestRecover(t *testing.T) {
	defer cleanup()
	panic("Something went wrong")
	fmt.Println("This line will not be executed")
}

4. 自定义错误类型

package define
import (
	"fmt"
	"testing"
	"time"
)

type TimeoutError struct {
	Operation string
	Timeout   time.Time
}

func (e TimeoutError) Error() string {
	return fmt.Sprintf("Timeout error during %s operation. Timeout at %s", e.Operation, e.Timeout.Format("2006-01-02 15:04:05"))
}

func PerformOperation() error {
	timeout := time.Now().Add(5 * time.Second)
	if time.Now().After(timeout) {
		return TimeoutError{Operation: "PerformOperation", Timeout: timeout}
	}
	return nil
}

func TestDefineError(t *testing.T) {
	err := PerformOperation()
	if err != nil {
		fmt.Println("Error:", err)
	} else {
		fmt.Println("Operation completed successfully.")
	}
}

（七）包和依赖管理

src 目录下创建 chapter7，Go 语言的包和依赖管理主要通过其内置的模块系统（Go Modules）来实现。

1. package（包）的基本知识点

• 包的可见性：首字母大写表示公有，小写表示私有。
• 同一目录里的 Go 代码的 package 要保持一致。

2. 构建一个自身可复用的 package

编写 my_series.go：

package series
import "fmt"

func init() {
	fmt.Println("init1")
}

func Square(n int) int {
	return n * n
}

func GetFibonacciSerie(n int) []int {
	ret := []int{1, 1}
	for i := 2; i < n; i++ {
		ret = append(ret, ret[i-2]+ret[i-1])
	}
	return ret
}

3. 导入和应用远程依赖

使用 go get 命令来下载并添加远程依赖到项目中。

package remote
import (
	"fmt"
	"testing"
	cm "github.com/easierway/concurrent_map"
)

func TestConcurrentMap(t *testing.T) {
	m := cm.CreateConcurrentMap(99)
	m.Set(cm.StrKey("key"), 10)
	value, ok := m.Get(cm.StrKey("key"))
	if ok {
		fmt.Println("Key found:", value)
	}
}

4. 包的依赖管理

Go Modules 提供了版本控制和模块隔离的机制，避免了上述问题。

（八）并发编程

src 目录下创建 chapter8，展开后续的学习。

1. 协程机制

Thread vs Goroutine

Goroutine 的调度原理

Go 运行时调度器通过 M:P:G 模型实现了 Goroutine 的高效调度。

直接的代码展示

package groutine
import (
	"fmt"
	"testing"
	"time"
)

func sayHello() {
	fmt.Println("Hello, Goroutine!")
}

func TestSayHello(t *testing.T) {
	go sayHello()
	time.Sleep(time.Millisecond * 10)
	fmt.Println("Main function finished")
}

2. 共享内存并发机制

未引入同步处理情况

package share_mem
import (
	"testing"
	"time"
)

func TestCounter(t *testing.T) {
	counter := 0
	for i := 0; i < 5000; i++ {
		go func() {
			counter++
		}()
	}
	time.Sleep(1 * time.Second)
	t.Logf("counter = %d", counter)
}

sync.Mutex

func TestCounterThreadSafe(t *testing.T) {
	var mut sync.Mutex
	counter := 0
	for i := 0; i < 5000; i++ {
		go func() {
			mut.Lock()
			defer mut.Unlock()
			counter++
		}()
	}
	time.Sleep(1 * time.Second)
	t.Logf("counter = %d", counter)
}

sync.WaitGroup

func TestCounterWaitGroup(t *testing.T) {
	var mut sync.Mutex
	counter := 0
	var wg sync.WaitGroup
	for i := 0; i < 5000; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			mut.Lock()
			defer mut.Unlock()
			counter++
		}()
	}
	wg.Wait()
	t.Logf("counter = %d", counter)
}

3. CSP 并发机制

Go 语言的并发机制是基于 CSP（Communicating Sequential Processes） 模型。

代码体验

package concurrency
import (
	"fmt"
	"testing"
	"time"
)

func AsyncService() chan string {
	retCh := make(chan string, 1)
	go func() {
		ret := service()
		retCh <- ret
	}()
	return retCh
}

func TestAsynService(t *testing.T) {
	retCh := AsyncService()
	otherTask()
	fmt.Println(<-retCh)
}

4. 多路选择和超时

多路选择（select）

select {
case msg1 := <-chan1:
	fmt.Println("Received", msg1)
case msg2 := <-chan2:
	fmt.Println("Received", msg2)
default:
	fmt.Println("No channel is ready")
}

超时机制

package timeout
import (
	"testing"
	"time"
)

func TestTimeout(t *testing.T) {
	ch := make(chan string)
	go func() {
		time.Sleep(3 * time.Second)
		ch <- "result"
	}()
	select {
	case result := <-ch:
		t.Errorf("Expected timeout, but received %s", result)
	case <-time.After(2 * time.Second):
		t.Log("Test passed: Operation timed out as expected")
	}
}

5. channel 的关闭和广播

通道的关闭

close(ch)

检测通道是否关闭：

msg, ok := <-ch
if !ok {
	// 通道已关闭
}

广播

package broadcast
import (
	"fmt"
	"sync"
	"testing"
	"time"
)

func TestSimpleBroadcast(t *testing.T) {
	dataCh := make(chan int)
	var wg sync.WaitGroup
	numConsumers := 3
	numMessages := 5

	for i := 0; i < numConsumers; i++ {
		wg.Add(1)
		go func(consumerID int) {
			defer wg.Done()
			for data := range dataCh {
				fmt.Printf("Consumer %d received: %d\n", consumerID, data)
			}
		}(i)
	}

	go func() {
		for i := 0; i < numMessages; i++ {
			dataCh <- i
			time.Sleep(500 * time.Millisecond)
		}
		close(dataCh)
	}()

	wg.Wait()
}

6. 简单的任务取消机制

package simplecancel
import (
	"fmt"
	"testing"
	"time"
)

func isCancelled(cancelChan chan struct{}) bool {
	select {
	case <-cancelChan:
		return true
	default:
		return false
	}
}

func TestCancel(t *testing.T) {
	cancelChan := make(chan struct{}, 0)
	for i := 0; i < 5; i++ {
		go func(i int, cancelCh chan struct{}) {
			for {
				if isCancelled(cancelCh) {
					break
				}
				time.Sleep(time.Millisecond * 5)
			}
			fmt.Println(i, "Cancelled")
		}(i, cancelChan)
	}
	cancel_1(cancelChan)
	time.Sleep(time.Second * 1)
}

7. context 与任务取消

在 Go 语言中，context 包是处理任务取消、超时控制和跨 API 边界传递请求范围数据的强大工具。

（九）经典并发任务

（十）测试

（十一）反射和 Unsafe

（十二）常见架构模式的实现

（十三）常见任务

（十四）性能调优

（十五）高可用性服务设计