当前位置： 首页 > article >正文

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

article 2024/11/29 10:52:14

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

文章目录

      • 1、并发基础, Goroutines和Channels
      • 2、基于共享变量的并发, sync.WaitGroup和sync.Mutex
      • 3、反射与底层编程

参考资料：

  • 1、框架
    go语言源码-124k,
    go精选框架-133k,
    go-gin-HTTP Web框架-80k,
    go-Llama 3.2框架-90k,
    rclone-云存储挂载-50k,
    go-zero-原生微服务框架-20k

  • 2、教程
    The Go programming language - 124k
    Go语言圣经 《The Go Programming Language》 中文版-4.5k
    Go语言高级编程-20k,
    go成长路线-6k，
    go学习指南-3k
    go基础语法-菜鸟

  • 3、应用
    7天实现web-gee和数据库orm框架-16k
    构建goweb应用-43k

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()
    }
}

http://www.kler.cn/a/414082.html

相关文章：

  • Linux八股积累与笔记
  • MySQL索引与分区：性能优化的关键
  • 软件报错：找不到vcomp140.dll的原因分析，总结六种解决vcomp140.dll的方法
  • 如何解决 java.rmi.NotBoundException: RMI 中没有绑定的对象问题？亲测有效的解决方法！
  • 【.net core】【sqlsugar】子查询时的注意事项（持续更新）
  • 双十一线上服务调用链路追踪SkyWalking实战分析
  • 【人工智能】从零构建一个文本分类器：用Python和TF-IDF实现
  • 软件工程——期末复习（适用于sdut）
  • vue-baidu-map基本使用
  • webpack 项目访问静态资源
  • 新型实时的端到端对象检测器
  • 大电流PCB设计
  • 什么是BIOS
  • 天锐绿盾加密软件与Ping32联合打造企业级安全保护系统，确保敏感数据防泄密与加密管理
  • Python毕业设计选题：基于django+vue的智能停车系统的设计与实现
  • nodejs相关知识介绍
  • 【机器学习】机器学习的基本分类-监督学习-线性回归（Linear Regression）
  • rabbitmq原理及命令
  • Git上传本地项目到远程仓库（gitee/github）
  • Java 与设计模式（14）：策略模式
  • QT：多ui界面显示
  • 嵌入式C语言技巧15：深入浅出：多线程编程中锁的选择与优化策略
  • Unity高效编程经验50条分享
  • 达梦docker版本数据库 重新初始化实例--比如大小写敏感参数设置不生效
  • Laravel8.5+微信小程序实现京东商城秒杀方案
  • SQL面试题——in和not in 不支持怎么办