Go调用C结构体函数触发异常导致服务终止该如何处理

问题根因 #

Go语言自带的recover()机制只能捕获Go runtime抛出的panic，C代码触发的段错误、内存越界、空指针访问等问题会直接向操作系统发送信号，会导致整个进程终止，无法被Go原生逻辑捕获。
另外你提供的C代码本身存在多个会触发崩溃的已知缺陷：

• 定义的struct order结构体未声明orderstatus、orderid字段，后续直接赋值属于内存越界访问
• 每次调用order_place都分配100万个order结构体的内存，无释放逻辑会导致内存泄漏，超大内存分配也有概率触发OOM崩溃
• 未做任何入参校验，非法参数传入后直接执行逻辑很容易触发各类内存错误
• printf("orderid..%s\n", i.usr);如果i.usr不是合法字符串指针，用%s格式化会直接触发段错误

解决方案 #

方案1：同进程内加固（适合C逻辑简单的场景） #

第一步：修复并加固C代码

首先补全结构体定义，添加入参校验，内部增加异常捕获逻辑，遇到错误直接返回空指针，避免信号抛到Go层：

// orderbook.h 补全字段
#ifndef _ORDERBOOK_H
#define _ORDERBOOK_H
#include <setjmp.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>

extern jmp_buf jmp_env;
#define CATCH_ERROR if (setjmp(jmp_env) != 0) { return NULL; }

typedef struct order order;
struct order {
        int tradeid;
        int side;
        int symbol;
        double amount;
        double price;
        int orderstatus; // 补全缺失字段
        uint64_t orderid; // 补全缺失字段
};
#endif

// orderbook.c 添加入参校验和异常处理
#include "orderbook.h"
jmp_buf jmp_env;

order* order_place(char *side,double amount,double price,char symbol[19])
{
    // 入参前置校验
    if (side == NULL || (strcmp(side, "ASK") != 0 && strcmp(side, "BID") != 0)) {
        return NULL;
    }
    if (amount <= 0 || price <= 0) {
        return NULL;
    }
    if (symbol == NULL || strlen(symbol) > 18) {
        return NULL;
    }
    for (int i=0; symbol[i]!='\0'; i++) {
        if (!isdigit(symbol[i])) return NULL;
    }

    // 捕获后续逻辑的崩溃
    CATCH_ERROR
    
    // 按需分配内存，不要每次分配100万个
    struct order *tradeorder= calloc(1,sizeof(struct order));
    if (tradeorder == NULL) return NULL;

    // 原有业务逻辑，注意修改printf的格式化符适配i.usr的类型
    clob_ord_t o=unxs_order(c, (clob_ord_t){CLOB_TYPE_LMT,parsed_side, amount, .lmt =price, .usr = (uintptr_t)out},NANPX);

    if (o.qty.dis + o.qty.hid > 0.dd) {
        i = clob_add(c, o);
        // 这里修改为对应i.usr类型的格式化符，比如是整数就用%lu
        printf("orderid..%lu\n", (uint64_t)i.usr);
        insertMap(hashTable, i.usr, i);
        flag=true;
        tradeorder[0].orderstatus=1;
        tradeorder[0].orderid=offerid;
        tradeorder[0].side=sid;
        tradeorder[0].symbol=atoi(symbol);
        tradeorder[0].amount=(double)o.qty.dis;
        tradeorder[0].price=price;
    }
    return tradeorder;
}

注：如果C代码内部调用的第三方库会触发崩溃，需要在第三方库的信号处理逻辑里加longjmp(jmp_env, 1)跳转到捕获点返回错误。

第二步：Go侧参数前置校验+内存安全处理

调用C函数前先校验参数合法性，同时手动释放C.CString分配的内存避免泄漏，判断返回值是否为空做错误处理：

package main

// #cgo LDFLAGS: -lYourCLibName
// #include "orderbook.h"
// #include <stdlib.h>
import "C"
import (
    "errors"
    "unsafe"
)

func PlaceOrder(side string, amount float64, price float64, symbol string) (*C.order, error) {
    // 前置参数校验，从源头避免传错参数
    if side != "ASK" && side != "BID" {
        return nil, errors.New("invalid side")
    }
    if amount <= 0 || price <= 0 {
        return nil, errors.New("amount/price must be positive")
    }
    if len(symbol) > 18 {
        return nil, errors.New("symbol too long")
    }
    for _, c := range symbol {
        if c < '0' || c > '9' {
            return nil, errors.New("symbol must be numeric")
        }
    }

    // 转换参数，后续手动释放内存
    cSide := C.CString(side)
    defer C.free(unsafe.Pointer(cSide))
    cSymbol := C.CString(symbol)
    defer C.free(unsafe.Pointer(cSymbol))

    o := C.order_place(cSide, C.double(amount), C.double(price), cSymbol)
    if o == nil {
        return nil, errors.New("call order_place failed")
    }
    return o, nil
}

方案2：进程级隔离（最高稳定性方案，适合C逻辑复杂无法完全根除崩溃的场景） #

将C逻辑封装为独立的可执行程序，Go主服务通过Unix Socket/本地HTTP和C服务通信，即使C服务崩溃，Go主服务完全不受影响，还可以配置systemd等守护进程自动重启C服务，从架构层面避免C代码崩溃影响Go服务可用性。

内容的提问来源于stack exchange，提问作者Alex Smith