在 Go 中的 json.Marshal 期间锁定对象

Question

我想在将结构编组为 json 时将 RLock/RUnlock 添加到结构中。
下面的示例显示了我尝试做的事情。但是，它不起作用，因为每次调用json.Marshal，它都会运行Object.MarshalJSON方法，该方法本身调用json.Marshal，导致无限循环。

例子：

package main

import (
    "fmt"
    "encoding/json"
    "sync"
)

type Object struct {
    Name string
    Value int

    sync.RWMutex
}

func (o *Object) MarshalJSON() ([]byte, error) {
    o.RLock()
    defer o.RUnlock()

    fmt.Println("Marshalling object")

    return json.Marshal(o)
}

func main() {
    o := &Object{Name: "ANisus", Value: 42}

    j, err := json.Marshal(o)
    if err != nil {
        panic(err)
    }
    fmt.Printf("%s\n", j)
}

Example in Playground

输出：

编组对象
编组对象
编组对象
...

显然，我可以在调用 json.Marshal 之前删除 MarshalJSON 方法并在主函数中调用 Lock()。但是，我的问题是：

有没有办法在结构的 MarshalJSON 方法中调用 json.Marshal（或者至少让 json 包处理编码）？

额外问题
为什么我的程序没有冻结？第二次递归调用 MarshalJSON 时，结构体不应该被锁定吗？

Answer 1

您可以为递归调用的类型设置别名。这里是Play。

别名类型（JObject）没有定义marshal函数，所以它不会无限递归

package main

import (
    "fmt"
    "encoding/json"
    "sync"
)

type Object struct {
    Name string
    Value int

    sync.RWMutex
}

//Type alias for the recursive call
type JObject Object

func (o *Object) MarshalJSON() ([]byte, error) {
    o.RLock()
    defer o.RUnlock()

    fmt.Println("Marshalling object")
    // This works because JObject doesn't have a MarshalJSON function associated with it
    return json.Marshal(JObject(*o)) 
}

func main() {
    o := &Object{Name: "ANisus", Value: 42}

    j, err := json.Marshal(o)
    if err != nil {
        panic(err)
    }
    fmt.Printf("%s\n", j)
}

Answer 2

简单回答： 您的程序由于无限递归而冻结。

您调用了json.Marshal(o)，在您的方法中看起来像MarshalJSON()，但不幸的是，您还在MarshalJSON() 中调用了json.Marshal(o)，这最终导致无限原因递归并耗尽系统内存

之所以称为common rookie mistake，是因为您的代码会导致无限递归。

这是使用String() 的代码的更简单版本

另一个递归示例：

package main

import "fmt"

type A int

func (a A) String() string {
    return fmt.Sprintf("%v", a)
}

func main() {
    var a A
    fmt.Println("this will never print", a)
}

这就是为什么 go 试图将 impose stack size limit 作为临时解决方案

2 个简单的解决方案

• 使用其他名称
• 不要返回return json.Marshal(o)，而是返回项目

解决方案 1 示例

package main

import (
    "encoding/json"
    "fmt"
    "sync"
)

type Object struct {
    Name  string
    Value int

    sync.RWMutex
}

func (o *Object) ParseJSON() ([]byte, error) {
    o.RLock()
    defer o.RUnlock()

    fmt.Println("Marshalling object")

    return json.Marshal(o)
}

func main() {
    o := &Object{Name: "ANisus", Value: 42}

    j, err := o.ParseJSON() // THis would work
    if err != nil {
        panic(err)
    }
    fmt.Printf("%s\n", j)

    j, err = json.Marshal(o) // this would work
    if err != nil {
        panic(err)
    }
    fmt.Printf("%s\n", j)
}

Live Demo

解决方案 2 示例

主包

import (
    "encoding/json"
    "fmt"
    "sync"
)

type Item struct {
    Name  string
    Value int

}
type Object struct {
    item Item
    sync.RWMutex
}

func (o *Object) MarshalJSON() ([]byte, error) {
    o.RLock()
    defer o.RUnlock()

    fmt.Println("Marshalling object")
    return json.Marshal(o.item)
}

func main() {
    o := &Object{item : Item{Name: "ANisus", Value: 42}}

    j, err := json.Marshal(o)
    if err != nil {
        panic(err)
    }
    fmt.Printf("%s\n", j)
}

Live Demo