【后端开发】Go语言编程实践,Goroutines和Channels,基于共享变量的并发,反射与底层编程

发布于:2024-11-29 ⋅ 阅读:(25) ⋅ 点赞:(0)

【后端开发】Go语言编程实践,Goroutines和Channels,基于共享变量的并发,反射与底层编程
【后端开发】Go语言高级编程,CGO、Go汇编语言、RPC实现、Web框架实现、分布式系统


参考资料:

1、并发基础, Goroutines和Channels

Goroutine 是 Go 中实现并发的基本单位。它是一种轻量级线程,使用 go 关键字启动。

  • 如果你使用过操作系统或者其它语言提供的线程,那么你可以简单地把goroutine类比作一个线程,这样你就可以写出一些正确的程序了。
  • 当一个程序启动时,其主函数即在一个单独的goroutine中运行,我们叫它main goroutine。新的goroutine会用go语句来创建。
  • 在语法上,go语句是一个普通的函数或方法调用前加上关键字go。go语句会使其语句中的函数在一个新创建的goroutine中运行。而go语句本身会迅速地完成。
go func() {
    // 这里是并发运行的代码
}()

func aaa(str string){}
go aaa("aa")

f()    // call f(); wait for it to return
go f() // create a new goroutine that calls f(); don't wait

Channels

  • 如果说goroutine是Go语言程序的并发体的话,那么channels则是它们之间的通信机制。一个channel是一个通信机制,它可以让一个goroutine通过它给另一个goroutine发送值信息。
  • 每个channel都有一个特殊的类型,也就是channels可发送数据的类型。一个可以发送int类型数据的channel一般写为chan int。
  • 和map类似,channel也对应一个make创建的底层数据结构的引用。当我们复制一个channel或用于函数参数传递时,我们只是拷贝了一个channel引用,因此调用者和被调用者将引用同一个channel对象。和其它的引用类型一样,channel的零值也是nil。
ch := make(chan int) 

ch <- x  // a send statement
x = <-ch // a receive expression in an assignment statement
<-ch     // a receive statement; result is discarded

close(ch) // 随后对基于该channel的任何发送操作都将导致panic异常。

ch = make(chan int)    // unbuffered channel
ch = make(chan int, 0) // unbuffered channel
ch = make(chan int, 3) // buffered channel with capacity 3

操作不同状态的chan会引发三种行为:

panic

  • 向已经关闭的通道写数据
  • 重复关闭通道

阻塞

  • 向未初始化的通道写/读数据
  • 向缓冲区已满的通道写入数据
  • 通道中没有数据,读取该通道

非阻塞

  • 读取已经关闭的通道,这个操作会返回通道元素类型的零值(可用comma, ok语法)
  • 向有缓冲且没有满的通道读/写
package main

import (
	"testing"
)

func TestChanOperateStatus(t *testing.T) {
	t.Run("向已经关闭的通道写数据", func(t *testing.T) {
		ch := make(chan int)
		close(ch) // 关闭通道
		ch <- 1   // 这里会引发panic,因为向已关闭的通道发送数据
		// panic: send on closed channel [recovered]
	})
	t.Run("重复关闭通道", func(t *testing.T) {
		ch := make(chan int)
		close(ch) // 第一次关闭通道
		close(ch) // 再次关闭通道会引发panic
		// panic: close of closed channel [recovered]
	})
	t.Run("向未初始化的通道写/读数据", func(t *testing.T) {
		var ch chan int
		go func() {
			ch <- 1
			// x := <-ch
		}()
		_ = <-ch
		// fatal error: all goroutines are asleep - deadlock!
	})
	t.Run("向缓冲区已满的通道写入数据", func(t *testing.T) {
		ch := make(chan int, 1)
		ch <- 1 // 第一次写入,缓冲区未满
		ch <- 2 // 这里会阻塞,因为缓冲区已满,没有goroutine读取数据
		// fatal error: all goroutines are asleep - deadlock!
	})
	t.Run("通道中没有数据,读取该通道", func(t *testing.T) {
		ch := make(chan int)
		_ = <-ch // 这里会阻塞,因为没有goroutine发送数据到通道
		// fatal error: all goroutines are asleep - deadlock!
	})
	t.Run("读取已经关闭的通道,这个操作会返回通道元素类型的零值(可用comma, ok语法)", func(t *testing.T) {
		ch := make(chan int)
		close(ch)     // 关闭通道
		x, ok := <-ch // x 将会是int类型的零值,ok 将会是false
		expectx, expectok := 0, false
		if ok != expectok && x != expectx {
			t.Errorf("expect 0, false, get %d, %t\n", x, ok)
		}
	})
	t.Run("向有缓冲且没有满的通道写,向有缓冲且不为空的通道读", func(t *testing.T) {
		ch := make(chan int, 2) // 1 也不会堵塞
		ch <- 1                 // 写入数据,不会阻塞
		_ = <-ch                // 读取数据,不会阻塞
	})
}

2、基于共享变量的并发, sync.WaitGroup和sync.Mutex

sync.WaitGroup 计数器,等待并发完成
sync.Mutex 互斥锁,保护共享资源
闭包,捕获外部变量的值

sync.WaitGroup 是一个计数器,用于等待一组 goroutine 完成。使用它的步骤如下:

  • 添加计数:使用 Add(n int) 方法增加计数,通常在启动 goroutine 之前调用。
  • 完成计数:在 goroutine 内部,使用 Done() 方法来减少计数。
  • 等待完成:使用 Wait() 方法阻塞当前 goroutine,直到计数器变为零。
var wg sync.WaitGroup

for i := 0; i < n; i++ {
    wg.Add(1) // 增加计数
    go func(i int) {
        defer wg.Done() // 在完成时减少计数
        // 某些操作
    }(i)
}

wg.Wait() // 等待所有 goroutine 完成

sync.Mutex 是一种互斥锁,用于保护共享资源,确保同一时间只有一个 goroutine 访问它。使用方法如下:

  • 锁定:使用 Lock() 方法加锁,确保线程安全。
  • 解锁:使用 Unlock() 方法解锁。通常推荐使用 defer 来确保在函数退出时解锁。
var mtx sync.Mutex

mtx.Lock() // 上锁
// 对共享资源的访问
mtx.Unlock() // 解锁

在并发操作中,通过收集错误并处理它们也是很常见的做法。可以使用切片来存储可能发生的错误,并且在访问这个切片时,需要使用 Mutex 来保证线程安全。

var errs []error
var mtx sync.Mutex

if err != nil {
    mtx.Lock()
    errs = append(errs, err)
    mtx.Unlock()
}

闭包
在 goroutine 内部,可以使用闭包来捕获外部变量的值。这对于确保在并发执行时每个 goroutine 使用到的是正确的变量非常重要。

for _, value := range values {
    go func(v string) {
        // 使用 v,确保 v 是当前循环中的值
    }(value)
}

结合以上组件,可以实现并发的操作,例如:

var wg sync.WaitGroup
var mtx sync.Mutex
var errs []error

for _, id := range ids {
    wg.Add(1)
    go func(id string) {
        defer wg.Done()
        
        // 假设这里是某个并发操作
        if err := doSomething(id); err != nil {
            mtx.Lock()
            errs = append(errs, err)
            mtx.Unlock()
        }
    }(id)
}

wg.Wait()

// 处理错误
if len(errs) > 0 {
    // 处理错误逻辑
}

3、反射与底层编程

反射:遍历不确定的结构体的每个字段,可以用反射来获取结构体的字段的值 。以及判断字段数据类型,在调用适当的函数,做神奇操作。
底层编程:cgo

反射是由 reflect 包提供的。它定义了两个重要的类型,Type 和 Value。一个 Type 表示一个Go类型。

  • 反射是程序在运行时能够“观察”并且修改自己的行为的能力。在Go语言中,反射是通过reflect包实现的,它提供了两个核心功能:Type和Value
  • 获取Type和Value:使用reflect.TypeOf()和reflect.ValueOf()可以获取变量的动态类型和值。TypeOf返回的是Type接口,而ValueOf返回的是Value接口
  • 类型和值的查询:通过Type和Value接口的方法,可以查询变量的类型信息和值。例如,Kind()方法可以返回一个常量,表示底层数据类型,如Uint、Float64、Slice等
  • 修改值:使用Value的Set()方法可以修改值,但需要注意的是,只有当值是可设置的(settable)时才能修改。可设置性意味着值必须通过指针传递,并且使用Elem()方法获取指针指向的值进行修改
  • 动态方法调用和字段访问:反射不仅可以用于基础类型和结构体,还可以用于动态地调用方法和访问字段。例如,可以通过MethodByName方法动态调用对象的方法
package main

import (
	"fmt"
	"reflect"
)

// 定义一个示例结构体
type Employee struct {
	Name     string
	Age      int
	Salary   float64
	Active   bool
}

// 一个通用函数,使用反射打印并修改结构体字段
func inspectAndModify(v interface{}, newValue interface{}) {
	// 获取传入值的反射值
	val := reflect.ValueOf(v)

	// 检查是否是指针类型,如果是,获取其元素
	if val.Kind() == reflect.Ptr {
		val = val.Elem()
	}

	// 打印结构体的字段
	fmt.Printf("结构体类型: %s\n", val.Type())
	fmt.Println("字段:")

	for i := 0; i < val.NumField(); i++ {
		field := val.Field(i)
		fieldType := val.Type().Field(i)

		// 打印字段名称和类型
		fmt.Printf("  %s (%s): %v\n", fieldType.Name, fieldType.Type, field)

		// 这里我们简单示例,用传入的值替换第一个可设置的字段
		if i == 0 && field.CanSet() {
			value := reflect.ValueOf(newValue)
			if value.Type().AssignableTo(field.Type()) {
				field.Set(value)
				fmt.Printf("  %s字段已更新为: %v\n", fieldType.Name, field)
			} else {
				fmt.Printf("  无法将值%v赋给字段%s,类型不匹配。\n", newValue, fieldType.Name)
			}
		}
	}
}

func main() {
	// 创建一个 Employee 实例
	emp := &Employee{Name: "Alice", Age: 30, Salary: 65000.0, Active: true}

	// 使用 inspectAndModify 函数打印结构体信息并修改字段
	inspectAndModify(emp, "Bob")

	// 打印修改后的结构体
	fmt.Println("修改后的 Employee:", emp)
}

// 结构体类型: main.Employee
// 字段:
//   Name (string): Alice
//   Name字段已更新为: Bob
//   Age (int): 30
//   Salary (float64): 65000
//   Active (bool): true
// 修改后的 Employee: &{Bob 30 65000 true}
package main

import (
	"fmt"
	"reflect"
)

type Person struct {
	Name    string
	Age     int
	Address string
}

func main() {
	// 创建一个Person实例
	p := Person{
		Name:    "John Doe",
		Age:     30,
		Address: "123 Main St",
	}

	// 获取Person实例的反射值
	v := reflect.ValueOf(p)

	// 确保v是一个结构体
	if v.Kind() == reflect.Struct {
		// 遍历结构体的所有字段
		for i := 0; i < v.NumField(); i++ {
			field := v.Field(i)
			// 获取字段的名称
			fieldName := v.Type().Field(i).Name
			// 获取字段的值
			fieldValue := field.Interface()
			fmt.Printf("Field: %s, Value: %v\n", fieldName, fieldValue)
		}
	}
}

Go的底层编程

  • Go的底层编程涉及到更接近硬件和操作系统的细节,包括内存管理、指针操作等。
  • unsafe包:Go提供了unsafe包,它允许程序员绕过Go的类型系统,进行指针操作和内存对齐等操作。unsafe包中的Sizeof、Alignof和Offsetof可以用于获取类型的存储大小、内存对齐和字段偏移量
  • unsafe.Pointer:unsafe.Pointer是一个特殊的类型,它可以存储任何类型的指针,并允许进行指针转换和算术操作
  • 调用C代码:通过cgo,Go程序可以调用C语言代码,这涉及到底层的内存管理和类型转换
  • 性能考虑:底层编程和反射操作通常比直接的Go操作要慢,因为它们涉及到额外的动态查询和类型转换。因此,在性能敏感的应用中需要谨慎使用
  • 要编译和运行这个示例,你需要确保你的Go环境可以使用cgo。通常,对于大多数操作系统,cgo是默认启用的。

调用c语言代码

// main.go
package main

/*
#include <stdio.h>
#include <stdlib.h>

// 定义转置函数
void transpose(int* src, int* dest, int rows, int cols) {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            dest[j * rows + i] = src[i * cols + j];
        }
    }
}
*/
import "C"
import (
    "fmt"
    "unsafe"
)

func main() {
    // 定义一个3x3的矩阵
    rows, cols := 3, 3
    src := []int{1, 2, 3, 4, 5, 6, 7, 8, 9}
    dest := make([]int, rows*cols)

    // 打印原始矩阵
    fmt.Println("原始矩阵:")
    printMatrix(src, rows, cols)

    // 调用C代码进行转置
    C.transpose((*C.int)(unsafe.Pointer(&src[0])), (*C.int)(unsafe.Pointer(&dest[0])), C.int(rows), C.int(cols))

    // 打印转置后的矩阵
    fmt.Println("转置后的矩阵:")
    printMatrix(dest, cols, rows)
}

func printMatrix(matrix []int, rows, cols int) {
    for i := 0; i < rows; i++ {
        for j := 0; j < cols; j++ {
            fmt.Printf("%d ", matrix[i*cols+j])
        }
        fmt.Println()
    }
}