分类 golang 下的文章

2024-08-13

Go语言的协程（goroutine）是由Go的运行时（runtime）调度的，而不是由程序员直接控制。Go的运行时会自动处理goroutine的调度，包括抢占式调度。

Go语言的运行时会定期检查每个goroutine的运行时间，如果某个goroutine运行时间过长，会强制让出CPU，让其他goroutine有机会执行。这个过程就是抢占式调度。

在Go中，你不能直接控制goroutine的抢占，因为这是由运行时自动管理的。但是，你可以通过以下方式来控制goroutine的行为：

使用runtime.Gosched来主动让出CPU，让出时间片给其他goroutine。
使用runtime.GOMAXPROCS来设置可以并行执行goroutine的CPU核心数目。

下面是一个简单的例子，展示了如何使用runtime.Gosched来让出CPU时间：




package main
 
import (
    "fmt"
    "runtime"
)
 
func printNumbers() {
    for i := 1; i <= 5; i++ {
        fmt.Println(i)
        if i == 3 {
            runtime.Gosched() // 主动让出CPU
        }
    }
}
 
func main() {
    runtime.GOMAXPROCS(1) // 设置使用单核心
    go printNumbers()
    printNumbers()
}

在这个例子中，printNumbers函数会打印数字。当数字达到3时，会调用runtime.Gosched来主动让出CPU。这样，在单核心处理器上，两个goroutine轮流运行，交替打印数字。如果没有runtime.Gosched，可能一个goroutine会一直运行，另一个goroutine无法获得CPU时间。

golang知识点总结

2024-08-13

在Go语言中，有许多重要的概念和特性，我们可以通过编写一些简单的代码示例来学习和理解它们。

变量声明和初始化：




// 单个变量声明和初始化
var a int = 10
 
// 多个变量一起声明和初始化
var b, c int = 1, 2
 
// 使用:=简写声明和初始化
d := 30

基本数据类型：




// 整数类型
var e int = 10
 
// 浮点类型
var f float32 = 5.5
 
// 字符串
var g string = "Hello, World!"
 
// 布尔类型
var h bool = true

控制流程：




// if 语句
if a > b {
    fmt.Println("a is greater than b")
} else {
    fmt.Println("a is not greater than b")
}
 
// for 循环
for i := 0; i < 10; i++ {
    fmt.Println(i)
}
 
// switch 语句
switch i {
case 1:
    fmt.Println("i is 1")
case 2:
    fmt.Println("i is 2")
default:
    fmt.Println("i is not 1 or 2")
}

函数：




// 定义一个函数
func add(a int, b int) int {
    return a + b
}
 
// 调用函数
result := add(1, 2)
fmt.Println(result)

指针：




// 声明一个变量
var a int = 10
 
// 获取变量的地址
var ptr *int = &a
 
// 使用指针访问变量的值
fmt.Println(*ptr)

数组和切片：




// 声明一个数组
var arr [5]int
 
// 声明并初始化一个数组
var arr1 [5]int = [5]int{1, 2, 3, 4, 5}
 
// 使用...自动推导数组长度
var arr2 = [...]int{1, 2, 3, 4, 5}
 
// 声明一个切片
var slice []int
 
// 声明并初始化一个切片
slice1 := []int{1, 2, 3, 4, 5}

结构体：




// 定义一个结构体
type Person struct {
    name string
    age  int
}
 
// 创建一个结构体实例
p := Person{"John", 30}
 
// 访问结构体字段
fmt.Println(p.name)

Map：




// 创建一个map
m := make(map[string]int)
 
// 添加键值对
m["one"] = 1
 
// 从map中获取值
v := m["one"]
fmt.Println(v)

并发：




// 启动一个goroutine
go func() {
    fmt.Println("Hello, concurrent world!")
}()
 
// 使用channel同步goroutines
c := make(chan int)
 
go func() {
    c <- 10
}()
 
x := <-c
fmt.Println(x)

Error处理：




// 错误处理
if err != nil {
    fmt.Println("An error occurred:", err)
    return
}

这些代码片段涵盖了Go语言的基础知识点，可以帮助开发者快速了解Go语言的基础。

【Go 语言入门专栏】Go 语言的起源与发展

2024-08-13

Go 语言起源与发展背景：

Go 语言起源于2007年，由Robert Griesemer, Rob Pike和Ken Thompson在Google公司内部开发。这三位都是计算机科学领域的重量级人物，其中Rob Pike曾是UTF-8编码的主要推动者，而Ken Thompson是C语言的主要设计者之一，同时也是Unix操作系统的主要开发者之一。

Go 语言的主要目标是提供一种简单有效的编程语言，用以开发高性能的服务器端应用程序，尤其是需要处理网络和多核心处理的应用程序。

Go 语言的发展历程：

2009年11月10日，Go 语言作为开放源代码发布。
2012年3月28日，Go 1.0 发布，Go 语言的首个正式版本。
2015年8月19日，Go 1.5 发布，引入了重要的新特性，如 vendoring 和 Go 工具链的改进。
2016年2月17日，Go 1.7 发布，增加了新的 gops 工具，用于实时查看运行中的Go程序的状态。
2018年2月16日，Go 1.10 发布，支持模块机制，并引入了新的内存管理和并发特性。
2019年2月25日，Go 1.12 发布，增加了对Windows/ARM的官方支持，并改进了GC（垃圾收集）。
2020年Feb，Go 1.14 发布，增加了对Mac M1芯片的官方支持。

Go 语言的特点：

静态类型
编译型
并发性
内存管理
高性能
语法简单
开源

Go 语言的应用领域：

服务器编程，如Docker、Kubernetes等
网络编程，如gRPC、Go-Ethereum等
分布式系统，如etcd、TiKV等
云平台，如OpenStack等
游戏开发，如魔兽世界的部分服务器
数据库内嵌式SQL数据库
区块链开发

Go 语言的未来发展：

随着技术的发展，Go 语言也将继续进化，提供更好的开发者体验，提升性能，保持语言的简洁和表达力，并与时俱进地适应新的开发挑战。

修复go tool pprof存在的“bug”

2024-08-13

go tool pprof是Go语言的性能分析工具，它可以用来分析CPU和内存的使用情况。如果你在使用go tool pprof时遇到了问题，可能是因为以下原因：

使用了错误的命令或参数。
分析的服务或程序有bug导致性能数据不准确。
go tool pprof自身可能存在bug。

针对这种情况，解决方法通常包括以下几个步骤：

确认你的Go版本是最新的，以便使用最新的pprof工具。
仔细检查你的命令和参数是否正确。
如果是在分析某个服务或程序，确保它没有bug，并且正确地导出性能数据。
如果确认是pprof的bug，可以尝试更新到最新版本的Go，或者在Go的问题跟踪系统中报告并提交bug。

以下是一个简单的示例，展示如何使用go tool pprof：




# 启动要分析的Go程序，确保开启性能分析
$ go run -gcflags "all=-N -l" main.go
 
# 使用pprof获取堆分配的样本
$ go tool pprof http://localhost:6060/debug/pprof/heap
 
# 使用交互式命令分析堆
(pprof) top
(pprof) list FuncName

确保你的程序正确开启了性能分析的端点，并且使用了正确的URL。如果你在使用上有问题，可以参考Go的官方文档或社区获取帮助。如果是pprof的bug，应该尽可能提供详细的信息和复现步骤，以便开发者修复。

01 基础入门编写你的第一个 Go 语言程序

2024-08-13




package main
 
import "fmt"
 
func main() {
    fmt.Println("Hello, 世界")
}

这段代码将输出 "Hello, 世界" 到控制台。这是学习任何编程语言时的典型入门程序，展示了 Go 语言的基本语法和结构。在这个简单的程序中，我们导入了 "fmt" 包，它提供了打印到控制台的函数。然后我们定义了一个 main 函数，这是程序的入口点，并在其中调用了 fmt.Println 函数来输出文本。

Go 版本 Etcd 客户端操作 Etcd（附完整 Demo）

2024-08-13




package main
 
import (
    "context"
    "fmt"
    "time"
 
    clientv3 "go.etcd.io/etcd/client/v3"
)
 
func main() {
    cli, err := clientv3.New(clientv3.Config{
        Endpoints:   []string{"localhost:2379"},
        DialTimeout: 5 * time.Second,
    })
    if err != nil {
        // handle error!
        fmt.Printf("connect to etcd failed, err:%v\n", err)
        return
    }
    defer cli.Close()
 
    ctx, cancel := context.WithTimeout(context.Background(), time.Second)
    defer cancel()
    resp, err := cli.Get(ctx, "key")
    if err != nil {
        // handle error!
        fmt.Printf("get failed, err:%v\n", err)
        return
    }
    for _, ev := range resp.Kvs {
        fmt.Printf("%s : %s\n", ev.Key, ev.Value)
    }
}

这段代码演示了如何使用Go语言和etcd/clientv3库来连接到Etcd服务器，并执行一个简单的Get操作。它首先创建了一个Etcd客户端，然后尝试获取键为"key"的数据。如果操作成功，它会打印出所有的键值对；如果有错误，它会记录错误信息。这个例子是etcd操作的基础，展示了如何开始使用etcd进行开发。

go通过go run命令启动出现undefined

2024-08-13

报错 "undefined" 在 Go 语言中通常不是一个标准错误信息，因为 Go 的编译器和运行时错误信息会更加具体。但是，如果在尝试使用 go run 命令启动 Go 程序时出现了 "undefined" 这个词，那么可能的原因是：

你尝试调用的函数或变量没有定义。
你可能导入了一个包，但是包中的某个函数或变量没有被正确导入。
你可能在代码中使用了一个未初始化的变量。

解决方法：

确保你调用的函数或变量已经在你的代码中定义。
如果是调用了包中的函数或变量，确保已经正确导入了该包，并且包中的函数或变量确实存在。
确保所有的变量在使用前都已经初始化。

具体步骤：

检查报错的函数或变量是否存在拼写错误。
检查是否导入了正确的包，并且包的路径是否正确。
如果是变量未初始化，给变量赋上一个初始值。
如果错误信息更具体，例如 "undefined: http.ListenAndServe"，则可能是因为你尝试调用的函数不属于标准库 net/http，确保没有遗漏 import 语句，或者检查是否导入了正确的包。

如果以上步骤无法解决问题，请提供更详细的错误信息，以便进行更准确的诊断。

client-go中ListAndWatch机制，informer源码详解

2024-08-13

ListAndWatch是Kubernetes API中的一种机制，它使得客户端可以监控etcd中的资源变化。client-go中的Informer机制就是基于这个原理实现的，它负责处理列表和监听资源变更的功能，并且维护着缓存，以便于高效的查询。

Informer的核心组件包括Reflector、DeltaFIFO、Indexer和Controller。

Reflector：是一个负责列表并监听资源变更的组件，它会不断地从API Server获取最新的资源状态，并将变更的部分传递给DeltaFIFO。

DeltaFIFO：是一个先进先出的队列，用于存储变更的资源，并将这些变更传递给Indexer。

Indexer：是一个本地缓存，用于存储资源的最新状态，并提供高效的查询能力。

Controller：负责处理并发控制，确保Informer的线程安全。

以下是一个简化的Informer工作流程图：

一次Golang单体架构中的复杂长函数的重构实践和思考

2024-08-13




package main
 
import (
    "fmt"
    "time"
)
 
// 假设的复杂逻辑函数
func complexFunction(a, b int) (int, error) {
    // 这里是函数的实现细节，可能涉及到复杂的逻辑
    // ...
    return a + b, nil
}
 
// 重构后的函数，拆分为多个小函数
func refactorComplexFunction(a, b int) (int, error) {
    // 先进行基本的参数校验和格式化
    if err := validateInputs(a, b); err != nil {
        return 0, err
    }
 
    // 执行主要的业务逻辑
    result := calculateResult(a, b)
 
    // 返回结果前可以进行额外的校验或处理
    return result, nil
}
 
// 校验输入参数是否有效
func validateInputs(a, b int) error {
    if a < 0 || b < 0 {
        return fmt.Errorf("输入参数不能小于0, a:%d, b:%d", a, b)
    }
    return nil
}
 
// 计算函数的主要逻辑
func calculateResult(a, b int) int {
    // 这里是函数的主要计算逻辑
    return a + b
}
 
func main() {
    start := time.Now()
    result, err := refactorComplexFunction(10, 20)
    if err != nil {
        fmt.Println("函数执行出错:", err)
    } else {
        fmt.Printf("函数执行结果: %d\n", result)
    }
    elapsed := time.Since(start)
    fmt.Printf("函数执行耗时: %s\n", elapsed)
}

这个代码实例展示了如何将一个复杂的单体函数进行重构，拆分为多个小函数，增强了代码的可读性和可维护性。同时，它还展示了如何使用Go语言的错误处理机制，以及如何在程序中测量函数执行的时间。

2024-08-13

报错问题：在Windows 11上使用MSYS2的GCC编译器编译使用了Confluent Kafka Go语言包的代码时出现链接错误。

可能的解释：

缺少依赖：可能是Confluent Kafka Go包依赖的某些库没有安装或者没有正确链接。
版本不兼容：Go版本、Confluent Kafka Go包版本或者依赖的库版本之间可能存在不兼容。
环境配置问题：MSYS2的配置可能有误，导致GCC无法找到正确的库文件。

解决方法：

确保所有依赖项已安装：使用pacman（MSYS2的包管理器）检查所有必需的依赖是否已安装。
更新库和Go环境：确保所有库都是最新的，同时也更新Go环境到最新稳定版本。
检查GCC的搜索路径：确保GCC的库搜索路径包含了所需依赖的路径。
使用静态链接：如果可能，尝试静态链接所有依赖的库，以避免动态链接问题。
查看错误日志：仔细阅读链接错误信息，查看是否有具体的库缺失或版本冲突信息，根据具体错误进行修复。
清理构建环境：尝试清理旧的构建文件和缓存，然后重新编译。

如果问题依然存在，可以考虑在Confluent Kafka的GitHub仓库中查找问题报告，或者在Stack Overflow等社区提问，寻求更具体的帮助。