Go语言进程间通信（IPC）实践指南-Golang-PHP中文网

Go语言进程间通信（IPC）实践指南

聖光之護

发布： 2025-08-26 22:24:18

原创

559人浏览过

go语言进程间通信（ipc）实践指南

本文旨在介绍在Go语言中实现进程间通信（IPC）的几种有效方法，包括Go内置的RPC系统、基于gob编码的数据传输以及使用命名管道进行通信。通过对这些方案的原理、优缺点以及适用场景进行分析，帮助开发者选择最适合自身需求的IPC方式，并提供相应的实践指导。

Go语言提供了多种进程间通信（IPC）机制，允许不同的Go进程之间交换数据和信息。选择合适的IPC方式对于构建高性能、可扩展的应用程序至关重要。以下介绍几种常用的Go语言IPC方法：

1. Go内置RPC系统

Go语言内置了net/rpc包，提供了一种简单易用的RPC（Remote Procedure Call，远程过程调用）机制。它允许一个进程调用另一个进程中的函数，就像调用本地函数一样。

优点：

立即学习“go语言免费学习笔记（深入）”；

易于使用：net/rpc包提供了简洁的API，简化了进程间通信的开发。
类型安全：RPC调用基于Go语言的类型系统，可以进行类型检查，减少错误。
跨平台：可以在不同的操作系统上使用。

缺点：

性能开销：RPC调用涉及网络传输和序列化/反序列化，会有一定的性能开销。
耦合性：客户端和服务端需要共享接口定义，存在一定的耦合性。

使用示例：

云雀语言模型

云雀是一款由字节跳动研发的语言模型，通过便捷的自然语言交互，能够高效的完成互动对话

查看详情

服务端代码：

package main

import (
    "fmt"
    "net"
    "net/rpc"
)

type Args struct {
    A, B int
}

type Quotient struct {
    Quo, Rem int
}

type Arith int

func (t *Arith) Multiply(args *Args, reply *int) error {
    *reply = args.A * args.B
    return nil
}

func (t *Arith) Divide(args *Args, quo *Quotient) error {
    if args.B == 0 {
        return fmt.Errorf("divide by zero")
    }
    quo.Quo = args.A / args.B
    quo.Rem = args.A % args.B
    return nil
}

func main() {
    arith := new(Arith)
    rpc.Register(arith)

    l, e := net.Listen("tcp", ":1234")
    if e != nil {
        fmt.Println("listen error:", e)
        return
    }

    for {
        conn, err := l.Accept()
        if err != nil {
            fmt.Println("accept error:", err)
            continue
        }
        go rpc.ServeConn(conn)
    }
}

登录后复制

客户端代码：

package main

import (
    "fmt"
    "log"
    "net/rpc"
)

type Args struct {
    A, B int
}

type Quotient struct {
    Quo, Rem int
}

func main() {
    client, err := rpc.Dial("tcp", "localhost:1234")
    if err != nil {
        log.Fatal("dialing:", err)
    }

    args := Args{A: 7, B: 8}
    var reply int
    err = client.Call("Arith.Multiply", &args, &reply)
    if err != nil {
        log.Fatal("arith error:", err)
    }
    fmt.Printf("Arith.Multiply: %d*%d=%d\n", args.A, args.B, reply)

    quotient := new(Quotient)
    err = client.Call("Arith.Divide", args, quotient)
    if err != nil {
        log.Fatal("arith error:", err)
    }
    fmt.Printf("Arith.Divide: %d/%d=%d remainder %d\n", args.A, args.B, quotient.Quo, quotient.Rem)
}

登录后复制

注意事项：

确保服务端和客户端共享相同的接口定义。
RPC调用可能会失败，需要进行错误处理。

2. Gob编码数据传输

encoding/gob包提供了一种高效的序列化/反序列化机制，可以将Go语言的数据结构编码成字节流，并通过网络连接进行传输。

优点：

立即学习“go语言免费学习笔记（深入）”；

效率高：gob编码针对Go语言的数据结构进行了优化，序列化/反序列化速度快。
类型安全：gob编码保留了数据类型信息，可以进行类型检查。
易于集成：可以与任何网络连接一起使用。

缺点：

仅限于Go语言：gob编码只能在Go语言的进程之间使用。
需要手动处理网络连接：需要自己编写代码来建立和管理网络连接。

使用示例：

服务端代码：

package main

import (
    "encoding/gob"
    "fmt"
    "net"
)

type Data struct {
    Message string
    Value   int
}

func main() {
    ln, err := net.Listen("tcp", ":1235")
    if err != nil {
        fmt.Println(err)
        return
    }
    defer ln.Close()

    conn, err := ln.Accept()
    if err != nil {
        fmt.Println(err)
        return
    }
    defer conn.Close()

    dec := gob.NewDecoder(conn)
    var data Data
    err = dec.Decode(&data)
    if err != nil {
        fmt.Println(err)
        return
    }

    fmt.Printf("Received: %+v\n", data)
}

登录后复制

客户端代码：

package main

import (
    "encoding/gob"
    "fmt"
    "net"
)

type Data struct {
    Message string
    Value   int
}

func main() {
    conn, err := net.Dial("tcp", "localhost:1235")
    if err != nil {
        fmt.Println(err)
        return
    }
    defer conn.Close()

    enc := gob.NewEncoder(conn)
    data := Data{Message: "Hello from client", Value: 42}
    err = enc.Encode(data)
    if err != nil {
        fmt.Println(err)
        return
    }

    fmt.Println("Sent:", data)
}

登录后复制

注意事项：