Published on

Golang的一些东西(十一)

Authors
  • avatar
    Name
    Et cetera
    Twitter

通过 context 进行 goroutine 的信息传递

在 Go 中,context.Context 是一个非常重要的标准库类型,可以用于传递请求范围的值、取消信号以及超时控制.Context 可以被用于在不同的 goroutine 之间传递数据和控制信号,以实现可靠且具有可取消性的程序.

下面是一个示例,演示如何使用 Context 实现多个 goroutine 之间的协作:

package main

import (
    "context"
    "fmt"
    "time"
)

func worker(ctx context.Context, id int) {
    for {
        select {
        case <-ctx.Done():
            fmt.Printf("Worker %d: context done\n", id)
            return
        default:
            fmt.Printf("Worker %d: working...\n", id)
            time.Sleep(time.Second)
        }
    }
}

func main() {
    // 创建一个带有取消信号的 context
    ctx, cancel := context.WithCancel(context.Background())

    // 启动多个 goroutine,它们可以监听 context 的取消信号并响应之
    for i := 0; i < 3; i++ {
        go worker(ctx, i+1)
    }

    // 等待一段时间后取消 context,所有的 goroutine 都会收到取消信号并退出
    time.Sleep(time.Second * 5)
    fmt.Println("Sending cancel signal...")
    cancel()

    // 等待所有的 goroutine 退出完成
    time.Sleep(time.Second)
    fmt.Println("All workers exited.")
}

在上面的示例中,我们创建了一个带有取消信号的 Context,并用它来启动了三个 worker 协程.每个 worker 都会不断地打印工作状态,并监听 Context 的取消信号.当我们在 main 函数中调用 cancel 函数后,所有的 worker 协程都会收到取消信号并停止工作.

通过使用 Context,我们可以非常方便地实现 goroutine 之间的通信和协作.在实际开发中,我们通常会将 Context 传递给多层函数、多个 goroutine,以实现更加灵活的协作模式.

rpc 是什么

RPC(远程过程调用)是一种计算机通信协议.它允许运行于一台计算机的程序调用另一台计算机的子程序(函数),而且程序员无需额外地为这个交互作编程.如果涉及的软件采用面向对象的方法,那么远程过程调用可以被看作是对面向对象的远程消息传递的一种形式.

RPC 是一种请求—响应协议:客户端发送请求包含有一个过程标识符和一些可能的参数,服务端将消息解包,计算结果,发送一个响应给客户端.RPC 协议是建立在其他的通信协议之上的,比如 HTTP 协议.客户端和服务器可以在不同的网络环境中.

以下是 RPC 的基本工作流程:

  1. 客户端调用客户端存根(client stub).调用过程就像是在本地进行函数调用一样.

  2. 客户端存根将函数参数打包到一个消息中,然后通过网络将这个消息发送给服务器.这个打包过程被称为参数序列化或者封送(marshalling).

  3. 服务器接收到这个消息,将其解包,得到函数参数,然后调用相应的服务端函数.

  4. 服务端函数完成调用后,将结果发送给服务端存根.

  5. 服务端存根将这个结果打包成消息,通过网络发送给客户端.

  6. 客户端存根接收到这个结果消息,将其解包,如果函数调用成功,返回给客户端.

所以,从客户端的角度来看,所有的过程就像是在本地进行函数调用一样,客户端不需要关心函数的实现和具体的运行位置.

RPC 通常用于实现分布式系统和微服务架构.它是一种允许应用程序跨网络请求服务的方式,其中服务位于远程系统上,并通过网络进行通信,让开发人员像本地调用函数一样调用远程函数.

一些主要的 RPC 系统和协议包括 Google 的 gRPC, Apache Thrift, JSON-RPC, XML-RPC等等.

需要注意的是,虽然 RPC 大大简化了开发分布式系统的复杂性,但是它也有一些缺点,比如错误处理复杂,因为网络请求可能会失败,或者服务器可能会崩溃;另外,由于网络延迟和服务器处理速度的原因,RPC 的调用通常比本地调用要慢很多.

使用 rpc 存在的潜在问题

虽然 RPC(远程过程调用)为分布式系统提供了一种有效的通信方式,但它也引入了一些问题和挑战.以下是一些主要的问题:

  1. 网络不稳定:在一个分布式系统中,网络可能不稳定.网络延迟、丢包、断开连接,都可能导致 RPC 调用失败.如果没有适当的错误处理和重试机制,这可能会导致程序的行为不确定.

  2. 性能问题:RPC 调用涉及到网络通信,这通常比在本地执行代码要慢得多.大量的 RPC 调用可能会导致性能瓶颈,尤其是在高延迟的网络环境中.

  3. 并发和同步问题:由于 RPC 调用可能会花费一些时间来完成,因此可能需要考虑并发和同步的问题.例如,如果一个 RPC 调用正在执行,而在此期间,本地代码需要等待该调用的结果,那么可能需要进行一些复杂的并发和同步操作.

  4. 服务发现问题:在分布式系统中,服务可能会动态地上线或下线,因此客户端需要一种机制来发现和跟踪可用的服务.虽然有一些服务发现协议和工具可以用于这个目的,但这本身就是一个复杂的问题.

  5. 版本控制问题:随着时间的推移,服务的接口可能会变化.如果客户端和服务器使用的是不同版本的服务接口,那么 RPC 调用可能会失败.因此,需要有一种机制来处理版本控制和向后兼容性的问题.

  6. 安全问题:RPC 调用可能会通过不安全的网络进行,因此可能会受到各种网络攻击,如中间人攻击、重放攻击等.需要在 RPC 系统中实施适当的安全措施,例如使用 TLS 加密 RPC 通信.

  7. 序列化和反序列化问题:RPC 调用通常需要通过序列化和反序列化参数和返回值来进行.不同的语言和平台可能支持不同的序列化格式,这可能会带来兼容性问题.此外,序列化和反序列化操作本身可能会消耗大量的 CPU 和内存资源,从而影响性能.

以上就是 RPC 可能带来的一些问题.解决这些问题需要精心设计和实现 RPC 系统,或者使用已经解决了这些问题的成熟的 RPC 框架,如 gRPC,Thrift 等.

分布式系统

分布式系统是由多台独立的计算机通过网络互相通信并协作完成任务的系统,这些计算机对于用户来说就像一台单一的计算机.分布式系统的目标是提供高可靠性、高可用性、可扩展性和容错性.

分布式系统的作用

  1. 高可靠性与容错性:在分布式系统中,如果一台机器宕机,服务可以由其他机器接管,提供持续服务.

  2. 高性能与可扩展性:在需要处理大量请求或大量数据的情况下,可以通过增加更多的服务器来增加系统的整体性能.

  3. 资源共享:分布式系统允许多个用户或程序共享硬件和软件资源.

分布式系统的使用场景

  1. 大数据处理:如 Hadoop 和 Spark,这些工具能够将计算任务分配到多台计算机上,处理大规模的数据集.

  2. 云计算:例如 Amazon Web Services(AWS)、Google Cloud Platform、Microsoft Azure 等,这些平台提供了构建和运行分布式应用程序的基础设施和服务.

  3. 分布式数据库:如 Cassandra,MongoDB 等,这些数据库可以将数据存储在多台服务器上,提供高可用性和可扩展性.

  4. 微服务架构:微服务将大型应用程序拆分为一组小的、自治的服务,这些服务可以独立部署和扩展.

在 Go 语言中使用分布式系统

Go 语言是谷歌开发的一种静态类型、编译型、并发型的编程语言,它由于其轻量级的并发模型(goroutine)、快速的运行速度、原生的网络库等特性,非常适合构建分布式系统和微服务.

例如,使用 Go 开发的 Docker 和 Kubernetes 都是目前广泛使用的分布式系统工具.Docker 允许开发者将应用和环境打包到一个可移植的容器中,而 Kubernetes 则是一个容器编排系统,可以管理和扩展运行在容器中的应用.

此外,gRPC 和 Go kit 等 RPC 框架也常用于 Go 语言的分布式系统开发.gRPC 是谷歌开源的一款高性能、通用的 RPC 框架,而 Go kit 是一款专门为 Go 语言设计的微服务工具包,这些工具可以帮助开发者更高效地构建和管理分布式系统.

总的来说,Go 语言在分布式系统的开发中有着广泛的应用,它提供的各种工具和库使得开发分布式系统更加容易和高效.

略微细究一下 goroutine

goroutine 是 Go 语言的并发设计核心.它是 Go 运行时环境管理的轻量级线程.goroutine 相对于传统的系统线程或者进程,它的创建和销毁,上下文切换的消耗更低,因此在 Go 中创建上百万个 goroutine 也是可能的.

goroutine 的特点:

  1. 轻量级:每个 goroutine 的栈初始只有很小(默认 2KB),而线程则默认在 1MB 左右,这使得在内存受限的环境下,Go 可以同时运行更多的 goroutine.

  2. 简单的并发编程模型:在 Go 程序中创建新的并发任务,只需要使用关键字go,后面跟上需要并发执行的函数或者方法,它将在新的 goroutine 中执行.

  3. Goroutine 调度:Go 使用了 M:N 的调度模型,M 个 goroutine 交给 N 个系统线程处理.其中 M,N 都可以动态伸缩,这种调度方式是由 Go 运行时进行控制的,而非由操作系统内核进行控制.

  4. 协作式抢占:Go 1.14 引入了协作式抢占调度,这使得长时间运行的 goroutine 无法阻塞调度器,并允许其他 goroutine 运行.

下面是一个简单的 goroutine 的使用例子:

package main

import (
	"fmt"
	"time"
)

func say(s string) {
	for i := 0; i < 5; i++ {
		time.Sleep(100 * time.Millisecond)
		fmt.Println(s)
	}
}

func main() {
	go say("world") // start a new goroutine
	say("hello")    // run in the main goroutine
}

在上面的例子中,main函数中的两个say函数调用是并发执行的.一个在新的 goroutine 中go say("world"),另一个在主 goroutine 中(say("hello")).

需要注意的是,当主 goroutine 结束时,所有其他 goroutine 也会立即结束,不论它们是否已经执行完毕.因此可能需要使用通道(channel)或者其他方法来同步等待 goroutine 的执行结果.

虽然 goroutine 是非常轻量级的,并且语法上的使用也非常简单,但是并发的编程模型仍然会引入复杂性,比如共享数据的访问冲突,goroutine 间的同步等问题.因此,在使用 goroutine 时,要仔细考虑并发控制的策略.

View on GitHub