并发编程模型
在Go语言中，提供了一种轻量级的并发编程模型，基于协程（Goroutine）和通道（Channel）。
协程
协程是一种用户态线程，由Go的运行时进行调度，相对于操作系统的线程，其资源占用较少。而且Go语言中的协程（Goroutine）并不是很重，一个典型的协程只需要使用1-2KB的栈空间。
协程的创建非常简单：
go func() {
// goroutine body
}()
使用go关键字，后接一个匿名函数即可创建一个新的协程，在新的协程中并发执行函数体中的代码。
通道
通道是一种数据结构，用于在Goroutine之间传递数据。通道是类型安全的，只能传递定义好的类型，而且通道提供了同步机制，可以保证数据传递的顺序和一致性。
通道的定义和使用：
var ch chan int // 定义通道
ch = make(chan int) // 初始化通道
ch <- 5 // 发送一个整数类型的数据（阻塞式）
x := <- ch // 从通道中读取数据（阻塞式）
分布式计算
在分布式计算中，通常需要将问题分解成多个小的计算任务，通过并行计算来提高计算速度。而在Go语言中，既可以使用并发模型，也可以通过RPC（Remote Procedure Call）来实现分布式计算。
RPC
RPC是一种远程过程调用协议，用于在不同的计算节点之间传递函数参数和返回值。在Go语言中，可以通过net/rpc包实现RPC协议的通信。使用RPC需要远程调用的函数必须满足以下条件：
函数是导出的（首字母大写）
函数有两个参数，第一个是请求参数，第二个是返回值参数，其中返回值参数是指针类型
函数返回一个error类型
RPC的代码实现：
// 定义一个请求参数的类型
type Args struct {
A, B int
}
// 定义一个返回值的类型
type Reply struct {
C int
}
// 定义一个具有RPC特性的函数
type Arith int
func (t *Arith) Multiply(args *Args, reply *Reply) error {
reply.C = args.A * args.B
return nil
}
// 启动RPC服务端
func main() {
arith := new(Arith)
rpc.Register(arith)
rpc.HandleHTTP()
l, e := net.Listen("tcp", ":1234")
if e != nil {
log.Fatal("listen error:", e)
}
http.Serve(l, nil)
}
通过上面的代码，可以将Multiply函数注册成为RPC服务，然后将rpc.HandleHTTP()绑定到http.DefaultServeMux上，再通过http.Serve()启动服务端，并等待客户端请求。客户端如下：
client, err := rpc.DialHTTP("tcp", "localhost:1234")
if err != nil {
log.Fatal("dialing:", err)
}
// 请求相乘的结果（C=A*B）
args := &Args{7, 8}
var reply Reply
err = client.Call("Arith.Multiply", args, &reply)
if err != nil {
log.Fatal("arith error:", err)
}
fmt.Printf("Multiply: %d*%d=%d\n", args.A, args.B, reply.C) // 7*8=56
结果合并
在分布式计算中，对于分解到不同计算节点上的任务，需要将其结果合并起来。适当地设计通道和协程，可以轻松地实现结果的合并。
以下是一个分解到不同计算节点执行的求和任务的例子：
func sum(arr []int, c chan int) {
sum := 0
for _, v := range arr {
sum += v
}
c <- sum // 发送本部分的计算结果
}
func main() {
arr := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
c := make(chan int)
go sum(arr[:len(arr)/2], c) // 半数参与计算
go sum(arr[len(arr)/2:], c) // 另一半参与计算
x, y := <-c, <-c
fmt.Println(x, y, x+y) // 输出每个部分的计算结果和最终结果
}
在上面的例子中，通过将数组分成两个部分，并发送到两个协程中计算，最后通过通道c将半数数组计算结果的和合并起来。