写两个函数也没什么关系，不用这么纠结。

    str := "1" +
        "2" +
        "3"

wg.Add(1)应该在go语句之前执行。

func main() {
    wg := sync.WaitGroup{}
    wg.Add(1)
    go func() {
        work()
        wg.Done()
    }()
    wg.Add(1)
    go func() {
        work()
        wg.Done()
    }()
    wg.Wait()
}

func Attributes() []interface{}

你要是嫌这个写法笨，其实自己实现MarshalJSON岂不是更笨？因为你这个例子根本就没有必要自己实现MarshalJSON。我写的只是一个示例，用来说明在自己实现MarshalJSON的情况下怎么做而已。
你要想容易维护扩展性能好，可以自己组织调整一下。
比如

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "strings"
)

type Person struct {
    Name string
}

func (p *Person) MarshalJSON() ([]byte, error) {
    var buf bytes.Buffer
    buf.WriteByte('{')
    p.marshalJSON(&buf)
    buf.WriteByte('}')
    return buf.Bytes(), nil
}

func (p *Person) marshalJSON(w io.Writer) {
    fmt.Fprintf(w, `"name":"%s"`, strings.ToLower(p.Name))
}

type Employee struct {
    Person
    JobRole string
}

func (e *Employee) MarshalJSON() ([]byte, error) {
    var buf bytes.Buffer
    buf.WriteByte('{')
    e.Person.marshalJSON(&buf)
    buf.WriteByte(',')
    fmt.Fprintf(&buf, `"jobRole":"%s"`, e.JobRole)
    buf.WriteByte('}')
    return buf.Bytes(), nil
}
func main() {
    p := Person{"Bob"}
    e := Employee{
        Person:  p,
        JobRole: "Sales",
    }
    output, err := json.Marshal(&e)
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println(string(output))
}

执行结束自然会退出。
你预期看到什么结果呢？

package main

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

type Person struct {
    Name string
}

func (p *Person) MarshalJSON() ([]byte, error) {
    str := fmt.Sprintf(`{"name":"%s"}`, strings.ToUpper(p.Name))
    return []byte(str), nil
}

type Employee struct {
    Person
    JobRole string
}

func (e *Employee) MarshalJSON() ([]byte, error) {
    str := fmt.Sprintf(`{"name":"%s", "jobRole":"%s"}`,
        strings.ToUpper(e.Name),
        e.JobRole)
    return []byte(str), nil
}

func main() {
    p := Person{"Bob"}
    e := Employee{
        Person:  p,
        JobRole: "Sales",
    }
    output, err := json.Marshal(&e)
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println(string(output))
}

SIGPIPE

When a Go program writes to a broken pipe, the kernel will raise a SIGPIPE signal.

If the program has not called Notify to receive SIGPIPE signals, then the behavior depends on the file descriptor number. A write to a broken pipe on file descriptors 1 or 2 (standard output or standard error) will cause the program to exit with a SIGPIPE signal. A write to a broken pipe on some other file descriptor will take no action on the SIGPIPE signal, and the write will fail with an EPIPE error.

If the program has called Notify to receive SIGPIPE signals, the file descriptor number does not matter. The SIGPIPE signal will be delivered to the Notify channel, and the write will fail with an EPIPE error.

This means that, by default, command line programs will behave like typical Unix command line programs, while other programs will not crash with SIGPIPE when writing to a closed network connection.

SetDeadline(time.Time{})就是恢复为阻塞模式。

A zero value for t means I/O operations will not time out.