func worker(url string, ch chan []string, fetcher Fetcher) {
    urls, err := fetcher.Fetch(url)
    if err != nil { // 爬取失败，返回错误
        ch <- []string{}
    } else {
        ch <- urls // fetch的url传入ch信道
    }
}

func master(ch chan []string, fetcher Fetcher) { // 创建worker从而fetch网页
    n := 1
    fetched := make(map[string]bool) // map映射，记录某一个url是否被爬取过，此处并需要给map加锁，因为它并没有被共享，是master私有的
    for urls := range ch { // 信道中非空则不断循环，*fetch到的url也换进入信道ch中*
        for _, u := range urls {
            if fetched[u] == false {
                fetched[u] = true
                n += 1
                go worker(u, ch, fetcher) // gorountine调用worker
            }
        }
        n -= 1
        if n == 0 { // 爬虫完成
            break
        }
    }
}

func ConcurrentChannel(url string, fetcher Fetcher) {
    ch := make(chan []string) // 创建信道
    go func() { // 闭包函数
        ch <- []string{url} // 发送url到master中，开启循环
    }()
    master(ch, fetcher)
}

// 为Client和Server定义相应的Args和return结构体
const ( // 定义常量
    OK       = "OK"
    ErrNoKey = "ErrNoKey"
)

type Err string // 错误信息

type PutArgs struct { // put操作传入参数
    Key   string
    Value string
}

type PutReply struct { // put操作返回
    Err Err
}

type GetArgs struct { // get操作传入参数
    Key string
}

type GetReply struct { // get操作返回
    Err   Err
    Value string
}

// Client端
func connect() *rpc.Client {
    client, err := rpc.Dial("tcp", ":1234") // 创建TCP连接，server的1234端口
    if err != nil {                         // 创建失败
        log.Fatal("dialing:", err)
    }
    return client
}

func get(key string) string {
    client := connect()                         // 获得连接
    args := GetArgs{key}                        // 设置传入参数结构体
    reply := GetReply{}                         // 设置返回参数结构体
    err := client.Call("KV.Get", &args, &reply) // 远程调用
    if err != nil {
        log.Fatal("error:", err)
    }
    client.Close() // 关闭
    return reply.Value
}

func put(key string, val string) {
    client := connect()
    args := PutArgs{key, val}
    reply := PutReply{}
    err := client.Call("KV.Put", &args, &reply) // 远程调用
    if err != nil {
        log.Fatal("error:", err)
    }
    client.Close()
}

// Server端
type KV struct {
    mu   sync.Mutex        // 互斥锁
    data map[string]string // 简单的映射表，模拟数据库
}

func server() {
    kv := new(KV) // 分配内存，初始化为0
    kv.data = map[string]string{}
    rpcs := rpc.NewServer()            // 注册RPC服务
    rpcs.Register(kv)                  // 注册kv为调用对象
    l, e := net.Listen("tcp", ":1234") // 监听1234端口
    if e != nil {
        log.Fatal("listen error:", e)
    }
    go func() { // goroutine执行
        for { // 循环，并发处理client请求
            conn, err := l.Accept()
            if err == nil {
                go rpcs.ServeConn(conn) // 另开线程，避免该线程阻塞。调用ServeConn实现解码，利用反射机制找到对应的函数执行后编码返回
            } else {
                break
            }
        }
        l.Close()
    }()
}

func (kv *KV) Get(args *GetArgs, reply *GetReply) error { // map为共享，所以必须传入指针
    kv.mu.Lock()
    defer kv.mu.Unlock() // 离开函数后释放，保证锁会被释放

    val, ok := kv.data[args.Key] // 常规处理，查找key
    if ok {
        reply.Err = OK
        reply.Value = val
    } else {
        reply.Err = ErrNoKey
        reply.Value = ""
    }
    return nil
}

func (kv *KV) Put(args *PutArgs, reply *PutReply) error {
    kv.mu.Lock()
    defer kv.mu.Unlock()

    kv.data[args.Key] = args.Value // 插入键值对
    reply.Err = OK
    return nil
}

func main() {
    server()
    put("subject", "6.824")
    fmt.Printf("Put(subject, 6.824) donen")
    fmt.Printf("get(subject) -> %sn", get("subject"))
}