Go和C如何共享内存资源

Go语言作为一个现代化的编程语言以及支持垃圾内存的自动回收特性(GC).
我们现在关注的是C语言返回的内存资源的自动回收技术.

CGO初步

Go语言的cgo技术允许在Go代码中方便的使用C语言代码. 基本的用法如下:

package rand

/*
#include <stdlib.h>
*/
import "C"

func Random() int {
    return int(C.random())
}

func Seed(i int) {
    C.srandom(C.uint(i))
}

其中"C"是导入一个虚拟的包, 用于引用C语言的符号.

Go语言和C语言通讯交互主要是通过传递参数和返回值. 其中参数和返回值除了基本的
数据类型外, 最重要的是如何相互传递/共享二进制的内存块.

Go向C语言传递内存块

这个最简单, 有很多现成的例子:

package print

// #include <stdio.h>
// #include <stdlib.h>
import "C"
import "unsafe"

func Print(s string) {
    cs := C.CString(s)
    C.fputs(cs, (*C.FILE)(C.stdout))
    C.free(unsafe.Pointer(cs))
}

因为C语言的字符串结尾有\0, Go语言字符串没有\0, 因此需要重新构造一个C字符串.
其中 C.CString(s) 是构造一个C的字符串, 然后复制字符串并传入 C.fputs.
用完之后不要忘记调用C.free释放新创建的C字符串(可以用defer释放).

如果是普通的内存块, 可以直接传递给C函数:

package main

// #include <stdlib.h>
import "C"
import "unsafe"

func Copy(dst, src []byte, size int) {
    C.memcpy(unsafe.Pointer(&dst[0]), unsafe.Pointer(&src[0]), C.size_t(size)
}

这个代码并没有涉及内存的创建/复制/删除等额外的操作, 是比较理想的集成方式.

注意: 在C语言使用该资源期间要防止Go语言的GC提前释放被C语言使用的Go内存!

C向Go语言返回内存块

如果是C语言向Go返回内存块, 一般是先创建一个对应的Go的切片. 有现成的函数C.GoBytes()可以基于C的内存块构造切片.

比如获取C返回的内存块数据:

package main

// #include <stdlib.h>
import "C"
import "unsafe"

func GetData() []byte {
    p := C.malloc(1024)
    defer C.free(p)
    return C.GoBytes(p, 1024)
}

代码并不复杂. 但是效率并不理想: 其中需要新创建一个Go的切片, 并进行一次冗余的复制操作.

如果想去掉冗余的复制操作, 就需要基于C的内存块构造切片. 这个需要依赖Go语言的反射技术.

package main

// #include <stdlib.h>
import "C"
import "unsafe"
import "reflect"

func GetData() []byte {
    p := C.malloc(1024)
    var s []byte
    h := (*reflect.SliceHeader)((unsafe.Pointer(&s)))
    h.Cap = 1024
    h.Len = 1024
    h.Data = uintptr(p)
    return s
}

返回的s是基于C语言内存块构造的切片. 没有冗余的内存复制操作.

但是, 上面的代码却有内存泄漏的问题. Go语言的GC并不会自动释放C.malloc释放的内存.

如果需要Go语言的GC自动管理C语言返回的内存, 需要基于之前讲过的 “Go语言资源自动回收技术[OSC源创会主题补充3]” .

简而言之, 就是要将C语言的内存块绑定到一个Go语言的内存资源, 然后依靠runtime.SetFinalizer的技术管理C语言的内存块.

核心代码如下:

type Slice struct {
    Data []byte
    data *c_slice_t
}

type c_slice_t struct {
    p unsafe.Pointer
    n int
}

func newSlice(p unsafe.Pointer, n int) *Slice {
    data := &c_slice_t{p, n}
    runtime.SetFinalizer(data, func(data *c_slice_t) {
        C.free(data.p)
    })
    s := &Slice{data: data}
    h := (*reflect.SliceHeader)((unsafe.Pointer(&s.Data)))
    h.Cap = n
    h.Len = n
    h.Data = uintptr(p)
    return s
}

其中 newSlice 基于C语言的内存块构造 Slice 结构体.
如果 Slice.data 资源没有被引用, 则会自动触发C语言的内存释放函数.

完整的测试代码

package main

/*
#include <stdio.h>
#include <stdlib.h>

void print(char* s) {
    printf("print: %s\n", s);
}
*/
import "C"
import (
    "fmt"
    "reflect"
    "runtime"
    "time"
    "unsafe"
)

type Slice struct {
    Data []byte
    data *c_slice_t
}

type c_slice_t struct {
    p unsafe.Pointer
    n int
}

func newSlice(p unsafe.Pointer, n int) *Slice {
    data := &c_slice_t{p, n}
    runtime.SetFinalizer(data, func(data *c_slice_t) {
        println("gc:", data.p)
        C.free(data.p)
    })
    s := &Slice{data: data}
    h := (*reflect.SliceHeader)((unsafe.Pointer(&s.Data)))
    h.Cap = n
    h.Len = n
    h.Data = uintptr(p)
    return s
}

func testSlice() {
    msg := "hello world!"
    p := C.calloc((C.size_t)(len(msg) + 1), 1)
    println("malloc:", p)

    s := newSlice(p, len(msg)+1)
    copy(s.Data, []byte(msg))

    fmt.Printf("fmt.Printf: %s\n", string(s.Data))
    C.print((*C.char)(p))
}

func main() {
    testSlice()

    runtime.GC()
    runtime.Gosched()
    time.Sleep(1e9)
}

测试程序的输出:

D:>go run hello.go
malloc: 0x6f7f50
fmt.Printf: hello world!
print: hello world!
gc: 0x6f7f50