今日任务：

1. LeetCode1049 最后一块石头的重量Ⅱ
2. LeetCode494 目标和
3. LeetCode474 一和零



资料来源：

1. [代码随想录 | LeetCode1049 最后一块石头的重量Ⅱ](https://programmercarl.com/1049.%E6%9C%80%E5%90%8E%E4%B8%80%E5%9D%97%E7%9F%B3%E5%A4%B4%E7%9A%84%E9%87%8D%E9%87%8FII.html)
2. [代码随想录 | LeetCode494 目标和](https://programmercarl.com/0494.%E7%9B%AE%E6%A0%87%E5%92%8C.html)
3. [代码随想录 | LeetCode474 一和零](https://programmercarl.com/0474.%E4%B8%80%E5%92%8C%E9%9B%B6.html)

### 1 LeetCode1049 最后一块石头的重量Ⅱ

:::info{title="题目"}
有一堆石头，用整数数组 stones 表示。其中 stones[i] 表示第 i 块石头的重量。

每一回合，从中选出任意两块石头，然后将它们一起粉碎。假设石头的重量分别为 x 和 y，且 x <= y。那么粉碎的可能结果如下：

如果 x == y，那么两块石头都会被完全粉碎；
如果 x != y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。
最后，最多只会剩下一块 石头。返回此石头 最小的可能重量 。如果没有石头剩下，就返回 0。

 

示例 1：
```
输入：stones = [2,7,4,1,8,1]
输出：1
解释：
组合 2 和 4，得到 2，所以数组转化为 [2,7,1,8,1]，
组合 7 和 8，得到 1，所以数组转化为 [2,1,1,1]，
组合 2 和 1，得到 1，所以数组转化为 [1,1,1]，
组合 1 和 1，得到 0，所以数组转化为 [1]，这就是最优值。
```
示例 2：
```
输入：stones = [31,26,33,21,40]
输出：5
```

提示：

- 1 <= stones.length <= 30
- 1 <= stones[i] <= 100
:::

我对着这题看了半天，愣没看出来哪里有背包。资料一语点醒梦中人：

> 本题其实就是尽量让石头分成重量相同的两堆，相撞之后剩下的石头最小，这样就化解成01背包问题了。

我：

![b303350d84ce8705397b8c6b2c5e8436.jpg](https://www.misaka19327.cc/static/img/e518e177f3ea97e3e8fa5a6edabf354a.b303350d84ce8705397b8c6b2c5e8436.jpg)

``` go
func lastStoneWeightII(stones []int) int {
	sum := 0
	for _, value := range stones {
		sum += value
	}
	target := sum / 2
	dp_array := make([]int, target + 1)
	for _, stone := range stones {
		for j := target; j >= stone; j-- {
			dp_array[j] = max(dp_array[j], dp_array[j - stone] + stone)
		}
	}
	return sum - dp_array[target] - dp_array[target] // 前俩算出来的是这么一大堆石头的另一半 最后再减去的是上面进行dp的目标 即求能组成的最靠近一半石头大小的石头组合
}
```

### 2 LeetCode494 目标和

:::info{title="题目"}
给你一个非负整数数组 nums 和一个整数 target 。

向数组中的每个整数前添加 '+' 或 '-' ，然后串联起所有整数，可以构造一个 表达式 ：

例如，nums = [2, 1] ，可以在 2 之前添加 '+' ，在 1 之前添加 '-' ，然后串联起来得到表达式 "+2-1" 。
返回可以通过上述方法构造的、运算结果等于 target 的不同 表达式 的数目。

 

示例 1：
```
输入：nums = [1,1,1,1,1], target = 3
输出：5
解释：一共有 5 种方法让最终目标和为 3 。
-1 + 1 + 1 + 1 + 1 = 3
+1 - 1 + 1 + 1 + 1 = 3
+1 + 1 - 1 + 1 + 1 = 3
+1 + 1 + 1 - 1 + 1 = 3
+1 + 1 + 1 + 1 - 1 = 3
```
示例 2：
```
输入：nums = [1], target = 1
输出：1
```

提示：

- 1 <= nums.length <= 20
- 0 <= nums[i] <= 1000
- 0 <= sum(nums[i]) <= 1000
- -1000 <= target <= 1000
:::

既然运算符只有加号和减号，那事情就好办了。数字无外乎加减，也就是说只要要加的那些的总和减去要减的那些的总和等于target就行了。再转换一下，要减的那些是所有元素的总和减去要加的那些。也就是说，要加的那些元素的总和x，所有元素的总和sum和target，存在一个$$x - (sum - x) = target$$，也就是$$2x - sum = target$$。一旦确定要求的是“从给定的数组中提取一些元素，使得总和x等于$$(sum + target) / 2$$”即可。

``` go
func findTargetSumWays(nums []int, target int) int {
	sum := 0
	for _, value := range nums {
		sum += value
	}
	if int(math.Abs(float64(target))) > sum || (target + sum) % 2 != 0 {
		return 0 // 必然无解 不能取整也是无解 可以以sum为5 target为2为例想一下
	}
        // 另外 sum == abs(target)不意味着只有一种方式 因为存在0的问题 0无论加减都不会影响总和
	dpTarget := (target + sum) / 2
	dpArray := make([]int, dpTarget + 1)
	dpArray[0] = 1
	for i := 0; i < len(nums); i++ {
		for j := dpTarget; j >= nums[i]; j-- {
			dpArray[j] += dpArray[j - nums[i]]
		}
	}
	return dpArray[dpTarget]
}
```

### 3 LeetCode474 一和零

:::info{title="题目"}
给你一个二进制字符串数组 strs 和两个整数 m 和 n 。

请你找出并返回 strs 的最大子集的长度，该子集中 最多 有 m 个 0 和 n 个 1 。

如果 x 的所有元素也是 y 的元素，集合 x 是集合 y 的 子集 。

 

示例 1：
```
输入：strs = ["10", "0001", "111001", "1", "0"], m = 5, n = 3
输出：4
解释：最多有 5 个 0 和 3 个 1 的最大子集是 {"10","0001","1","0"} ，因此答案是 4 。
其他满足题意但较小的子集包括 {"0001","1"} 和 {"10","1","0"} 。{"111001"} 不满足题意，因为它含 4 个 1 ，大于 n 的值 3 。
```
示例 2：
```
输入：strs = ["10", "0", "1"], m = 1, n = 1
输出：2
解释：最大的子集是 {"0", "1"} ，所以答案是 2 。
```

提示：

- 1 <= strs.length <= 600
- 1 <= strs[i].length <= 100
- strs[i] 仅由 '0' 和 '1' 组成
- 1 <= m, n <= 100
:::

~~那谁还能想到价值也能变成二维的价值呢。~~

这个确实是01背包，因为子集元素只能取一次。但是和01背包对应还是有点难对上。背包指的是子集，给定的strs里的每个元素就是物品，重量恒定为1，**质量却有两个维度：0的个数和1的个数**，所以写01背包往前查的时候必须按两个维度往前查才可以！

``` go
func findMaxForm(strs []string, m int, n int) int {
	dpArray := make([][]int, m + 1)
	for value := range dpArray {
		dpArray[value] = make([]int, n + 1)
	}
	for _, str := range strs {
		zeroNum, oneNum := 0, 0 // 统计0和1的个数
		for _, char := range str {
			if char == '0' {
				zeroNum += 1
			} else {
				oneNum += 1
			}
		}
                // 虽然dpArray是二维的 但是因为“物品”的价值也是二维的 所以写法一定是一维的
		for i := m; i >= zeroNum; i-- {
			for j := n; j >= oneNum; j-- {
				dpArray[i][j] = max(dpArray[i][j], dpArray[i - zeroNum][j - oneNum] + 1) // 从两个维度往前查
			}
		}
	}
	return dpArray[m][n]
}
```

代码随想录算法训练营第四十三天 | LeetCode1049 最后一块石头的重量Ⅱ、LeetCode494 目标和、LeetCode474 一和零

网络编程技术 设计性实验2：Linux下的TCP文件共享系统

GeeCache分布式缓存 | 第七天记录

主要内容：

1. Day6 防止缓存击穿



### 1 Day6 防止缓存击穿

还是拿昨天的图说明。

![aa203d2d34545afb6afb03262027c2a.jpg](https://www.misaka19327.cc/static/img/670e495a95cd3ea279dfc5e976ed3eca.aa203d2d34545afb6afb03262027c2a.jpg)

在这套流程里，如果一次性对同一个接口请求多次，那么这些请求也会一直到缓存里甚至是数据库里，有可能引发缓存击穿，毕竟这套流程里并没有对请求和调用进行限制。

对此，可以在GeeCache里通过实现一个singleflight的包来进行并发保护。

``` go
// src/geecache/singleflight/singleflight.go
package singleflight

import "sync"

// call 含义为正在进行中 或者是已经结束的请求
type call struct {
	wg sync.WaitGroup // 避免重入
	val interface{}
	err error
}

// Group 对call进行管理
type Group struct {
	mu sync.Mutex // 互斥锁 这个锁是保护下面的m的
	m map[string]*call
}

// DoFunc 要保护的方法调用入口 针对同样的key 传入的fn只会被调用一次 直到第一次fn的调用完成
func (g *Group) DoFunc (key string, fn func() (interface{}, error)) (interface{}, error) {
	g.mu.Lock() // 加锁
	
	if g.m == nil { // 如果没初始化的话先初始化
		g.m = make(map[string]*call)
	}
	
	if c, ok := g.m[key]; ok { // 已经存在之前的请求 则等待之前的请求完成 直接返回之前的请求结果
		g.mu.Unlock() // 读m完成 解锁
		c.wg.Wait() // 等待信号量归零
		return c.val, c.err
	}
	
	// 如果不存在相同的请求 则新增请求
	c := new(call)
	c.wg.Add(1) // 开始调用 信号量+1
	g.m[key] = c // 写入m
	g.mu.Unlock() // 读写m完成 解锁
	
	c.val, c.err = fn() // 实际调用
	c.wg.Done() // 调用已完成 信号量-1
	
	g.mu.Lock() // 加锁
	delete(g.m, key) // 请求结束 删除
	g.mu.Unlock() // 写入m完成 解锁
	
	return c.val, c.err
}
```

之后再融合进Group中：

``` go
// src/geecache/geecache.go
// 仅展示修改的三个部分

// Group 缓存对外交互的核心数据结构
type Group struct {
	name string // 该缓存的标识
	getter Getter // 缓存未能命中时的回调函数 类型是Getter接口
	mainCache cache // 缓存主体 是具有并发保护的LRU缓存
	peers PeerPicker // 这是实现了PeerPicker的HTTPPool
	// attention 为什么要将远程节点集成进HTTPPool 而不是节点本身？ 是否可以优化？
	
	loader *singleflight.Group // 非本地缓存的并发请求管理
}

// NewGroup 构造函数
func NewGroup(name string, cacheBytes int64, getter Getter) *Group {
	if getter == nil {
		panic("nil getter")
	}
	mu.Lock()
	defer mu.Unlock()
	group := &Group{
		name: name,
		getter: getter,
		mainCache: cache{cacheBytes: cacheBytes},
		loader: &singleflight.Group{},
	}
	groups[name] = group
	return group
}

// load 缓存未命中时 从别的地方加载缓存
func (g *Group) load(key string) (value ByteView, err error) {
	viewi, err := g.loader.DoFunc(key, func() (interface{}, error) {
		if g.peers != nil {
			if peer, ok := g.peers.PickPeer(key); ok { // 先从存储着远程节点信息的HTTPPool中选出具体的远程节点
				if value, err := g.getFromPeer(peer, key); err != nil { // 再根据这个具体的远程节点开始请求
					return value, nil
				}
				log.Println("[GeeCache] Failed to get from peer", err)
			}
		}
		return g.getFromLocal(key)
	})
	
	if err == nil {
		return viewi.(ByteView), err
	}
	return
}
```

GeeCache分布式缓存 | 第六天记录

主要内容：

1. 分布式节点 节点间通讯



### 1 Day5 分布式节点

想要实现分布式节点，先要明白GeeCache整体的服务过程，它的工作过程应该大致是这样的：

![224d301f6fa4b8b8784c4b9c0ce20f8.jpg](https://www.misaka19327.cc/static/img/ccc745d6a3a4bc5b293a0d4e8fe06c5b.224d301f6fa4b8b8784c4b9c0ce20f8.jpg)

要想要实现图中这个流程，就意味着一个缓存就得配一个HTTP服务端+客户端，这个客户端要有三个功能：第一、存储所有可用的节点；第二、对于给定的key，要能通过一致性哈希找到对应的远程节点，同时这个远程节点不能是自己；第三、请求这个远程节点。这三个功能完成之后，主缓存就可以直接调用函数来访问远程节点，而不用关心具体是哪个远程节点了。

#### 1 HTTP客户端

先抽象出两个接口：

``` go
// src/geecache/peer.go
package geecache

// PeerPicker 接口 根据key挑选远程节点
type PeerPicker interface {
	PickPeer(key string) (peerGetter PeerCacheValueGetter, ok bool)
}

// PeerCacheValueGetter 接口 根据key和给定的group获取缓存值
type PeerCacheValueGetter interface {
	GetCacheFromPeer(group string, key string) ([]byte, error)
}
```

> 第二个接口，原来的名字PeerGetter和方法Get实在太过于不明确了，我给改了个名字，之前的一些方法，接口也是，有一些实在容易分不清的也改名了。~~感觉作者是不是对Get这个词有点太喜欢了。~~

:::tip{title="提示"}
我曾想过这里的这两个接口是否有一些多余，不过Github上的讨论区里作者的回复比较合理：

> Q：第一步就抽象出接口，感觉不是很好理解。根据这篇文章https://blog.chewxy.com/2018/03/18/golang-interfaces/ ，是否可以考虑延迟定义接口。即首先定义类型/struct，在会使用到接口的时候再定义接口。
>
> A：一般抽象出接口是为了扩展性，很多场景下需要优先抽象接口。比如 RPC 通信需要支持不同的编解码方式，那首先想到的是一个支持编解码的结构体需要支持哪些方法，即接口。GeeRPC第一天 服务端与消息编码 在这篇文章中体现了这种思考方式。
> 
> 我觉得你说的也是有道理的，如果是比较确定的业务，优先 struct，需要扩展时再抽象接口更符合直觉一些。不过对于实现框架的童鞋来说，可扩展性是第一位的，所以一般都会优先设计接口。比如 go-micro 这个微服务框架，所有的参数都是接口类型的，这个框架是完全可插拔的，允许用户替换任意的类，只要 struct 实现了接口就行。
:::

之后就是实现HTTP客户端的功能，并在原有的HTTPPool上追加功能。

``` go
// src/geecache/http.go
// httpClient HTTP客户端 向远程节点发送请求 一个远程节点对应一个客户端
type httpClient struct {
	baseURL string
}

// GetCacheFromPeer 实现PeerCacheValueGetter接口 从远程节点获得缓存
func (h *httpClient) GetCacheFromPeer(group string, key string) (result []byte, err error) {
	url := fmt.Sprintf("%v%v/%v", h.baseURL, url.QueryEscape(group), url.QueryEscape(key))
	
	resp, err := http.Get(url)
	if err != nil {
		result = nil
		return
	}
	defer resp.Body.Close()
	
	if resp.StatusCode != http.StatusOK {
		result = nil
		err = fmt.Errorf("server returned error: %v", resp.Status)
	}
	
	bytes, err := io.ReadAll(resp.Body) // 读取响应体 原有的ioutil.ReadAll方法被弃用
	if err != nil {
		result = nil
		err = fmt.Errorf("reading response body error: %v", err)
	}
	
	result = bytes
	err = nil
	return
}

var _ PeerCacheValueGetter = (*httpClient)(nil) // 检查接口是否被完整实现
```

``` go
// src/geecache/http.go
package geecache

import (
	"GeeCache/src/geecache/consistenthash"
	"fmt"
	"io"
	"log"
	"net/http"
	"net/url"
	"strings"
	"sync"
)

const (
	defaultBasePath = "/_geecache/" // 默认资源地址
        // New
	defaultReplicas = 50 // 默认真实节点和虚拟节点倍数
)

// HTTPPool 一个缓存对应一个HTTP池 记录自身的地址和URL
type HTTPPool struct {
	selfAddr string // 记录缓存自身的地址 包括端口
	basePath string // 记录URL
        // New
	mu sync.Mutex // 锁
        // New
	peers *consistenthash.Map // 记录所有远程节点
        // New
	httpGetters map[string]*httpClient // 集成一个HTTP客户端
}

// NewHTTPPool HTTPPool的构造方法
func NewHTTPPool(selfAddr string) (result *HTTPPool) {
	result = &HTTPPool{
		selfAddr: selfAddr,
		basePath: defaultBasePath,
	}
	return
}

// Log 记录信息 参数v可传多个值 这些值会按format来进行格式化 再进入log
func (pool *HTTPPool) Log(format string, v ...interface{}) {
	log.Printf("[Server %s] %s", pool.selfAddr, fmt.Sprintf(format, v...))
}

// ServeHTTP HTTP服务端的Handler方法 对有效的缓存请求进行响应
func (pool *HTTPPool) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	if !strings.HasPrefix(r.URL.Path, pool.basePath) { // 检查请求是否有效
		panic("HTTPPool is serving unexpected path: " + r.URL.Path)
	}
	pool.Log("%s %s", r.Method, r.URL.Path) // log记录该次请求的信息
	
	parts := strings.SplitN(r.URL.Path[len(pool.basePath):], "/", 2)
	if len(parts) != 2 { // 检查请求是否有效
		http.Error(w, "bad request", http.StatusBadRequest) // 400
		return
	}
	
	groupName := parts[0]
	key := parts[1]
	
	group := GetGroup(groupName)
	if group == nil { // 请求的缓存不存在
		http.Error(w, "no such group:" + groupName, http.StatusNotFound) // 404
		return
	}
	view, err := group.GetFromCache(key)
	if err != nil { // 缓存请求失败
		http.Error(w, err.Error(), http.StatusInternalServerError) // 500
		return
	}
	
	w.Header().Set("Content-Type", "application/octet-stream")
	_, err = w.Write(view.GetByteCopy())
	if err != nil { // 写入响应失败
		http.Error(w, "write into responseWriter error: " + err.Error(), http.StatusInternalServerError) // 500
		return
	}
}

// New
// SetNewPeer 在本节点初始化远程节点信息
func (p *HTTPPool) Set(peers ...string) {
	p.mu.Lock() // attention 加锁必要性？
	defer p.mu.Unlock()
	
	p.peers = consistenthash.NewMap(nil, defaultReplicas)
	p.peers.AddRealNode(peers...)
	p.httpGetters = make(map[string]*httpClient, len(peers))
	for _, peer := range peers {
		p.httpGetters[peer] = &httpClient{baseURL: peer + p.basePath}
	}
}

// New
// PickPeer 根据一致性哈希挑选合适的远程节点
func (p *HTTPPool) PickPeer(key string) (PeerCacheValueGetter, bool) {
	p.mu.Lock()
	defer p.mu.Unlock()
	if peer := p.peers.GetRealNodeByKey(key); peer != "" && peer != p.selfAddr { // 注意这里 这里排除了自身节点
		p.Log("PickPeer picked %s", peer)
		return p.httpGetters[peer], true
	}
	return nil, false
}

var _ PeerPicker = (*HTTPPool)(nil) // 检查PeerPicker接口是否已完全实现
```

#### 2 集成进geecache中

``` go
// src/geecache/geecache.go
package geecache

import (
	"fmt"
	"log"
	"sync"
)

// Getter 接口 规定了一个Get方法 该方法用于规定缓存未命中时从哪里获得新的缓存
type Getter interface {
	Get(key string) ([]byte, error)
}

// GetterFunc 函数类型 专门用来实现Getter接口的函数类型
type GetterFunc func(key string) ([]byte, error)

// Get GetterFunc类下的 从Getter接口的Get函数实现而来的函数
func (function GetterFunc) Get(key string) ([]byte, error) {
	return function(key)
}

// Group 缓存对外交互的核心数据结构
type Group struct {
	name string // 该缓存的标识
	getter Getter // 缓存未能命中时的回调函数 类型是Getter接口
	mainCache cache // 缓存主体 是具有并发保护的LRU缓存
        // New
	peers PeerPicker // 这是实现了PeerPicker的HTTPPool
        // attention 为什么要将远程节点集成进HTTPPool 而不是节点本身？ 是否可以优化？
}

// 全局变量
var (
	mu sync.RWMutex // 互斥锁的高级版本 读写锁 在原有的锁功能上 增加读写特性 当读锁锁定时 只会阻止写 同理当写锁锁定时 会同时阻止读写
	groups = make(map[string]*Group) // 保存多个Group缓存
)

// NewGroup 构造函数
func NewGroup(name string, cacheBytes int64, getter Getter) *Group {
	if getter == nil {
		panic("nil getter")
	}
	mu.Lock()
	defer mu.Unlock()
	group := &Group{
		name: name,
		getter: getter,
		mainCache: cache{cacheBytes: cacheBytes},
	}
	groups[name] = group
	return group
}

// GetGroup 获取Group缓存
func GetGroup(name string) *Group {
	mu.RLock()
	g := groups[name]
	mu.RUnlock()
	return g
}

// GetFromCache 从缓存中获取值
func (g *Group) GetFromCache(key string) (ByteView, error) {
	if key == "" {
		return ByteView{}, fmt.Errorf("key is required")
	}
	if v, isOk := g.mainCache.get(key); isOk { // 缓存命中
		log.Println("[GeeCache] hit")
		return v, nil
	}
	// 缓存未命中 调用load函数
	return g.load(key)
}

// load 缓存未命中时 从别的地方加载缓存
func (g *Group) load(key string) (value ByteView, err error) {
        // New
	if g.peers != nil {
		if peer, ok := g.peers.PickPeer(key); ok { // 先从存储着远程节点信息的HTTPPool中选出具体的远程节点
			if value, err := g.getFromPeer(peer, key); err != nil { // 再根据这个具体的远程节点开始请求
				return value, nil
			}
			log.Println("[GeeCache] Failed to get from peer", err)
		}
	}
	return g.getFromLocal(key)
}

// getFromLocal 从本地加载缓存 在这里调用Getter的Get函数 并且通过populateCache存入缓存
func (g *Group) getFromLocal(key string) (ByteView, error) {
	bytes, err := g.getter.Get(key)
	if err != nil {
		return ByteView{}, err
	}

	value := ByteView{cacheBytes: cloneBytes(bytes)}
	g.populateCache(key, value)
	return value, nil
}

// populateCache 新的缓存值 存入缓存
func (g *Group) populateCache(key string, value ByteView) {
	g.mainCache.add(key, value)
}

// New
// RegisterPeers 将初始化完成的HTTPPool注入到group中 仅一次
func (g *Group) RegisterPeers(peers PeerPicker) {
	if g.peers == nil {
		panic("RegisterPeerPicker called more than once")
	}
	g.peers = peers
}

// New
// getFromPeer 从远程节点获得缓存
func (g *Group) getFromPeer(peer PeerCacheValueGetter, key string) (ByteView, error) {
	bytes, err := peer.GetCacheFromPeer(g.name, key)
	if err != nil {
		return ByteView{}, err
	}
	return ByteView{cacheBytes: bytes}, nil
}
```

到此，GeeCache主体部分就完成了，之后几天的内容就是对GeeCache进行改进。

### 2 项目整体示意&流程图

![aa203d2d34545afb6afb03262027c2a.jpg](https://www.misaka19327.cc/static/img/670e495a95cd3ea279dfc5e976ed3eca.aa203d2d34545afb6afb03262027c2a.jpg)

### 3 测试文件

``` go
package main

import (
	"GeeCache/src/geecache"
	"flag"
	"fmt"
	"log"
	"net/http"
)

var db = map[string]string{
	"Tom":  "630",
	"Jack": "589",
	"Sam":  "567",
}

func createGroup() *geecache.Group {
	return geecache.NewGroup("scores", 2<<10, geecache.GetterFunc(
		func(key string) ([]byte, error) {
			log.Println("[SlowDB] search key", key)
			if v, ok := db[key]; ok {
				log.Printf("[SlowDB] searched key: %s", v)
				return []byte(v), nil
			}
			return nil, fmt.Errorf("%s not exist", key)
		}))
}

func startCacheServer(addr string, addrs []string, gee *geecache.Group) {
	peers := geecache.NewHTTPPool(addr)
	peers.SetNewPeer(addrs...)
	gee.RegisterPeers(peers)
	log.Println("geecache is running at", addr)
	log.Fatal(http.ListenAndServe(addr[7:], peers))
}

func startAPIServer(apiAddr string, gee *geecache.Group) {
	http.Handle("/api", http.HandlerFunc(
		func(w http.ResponseWriter, r *http.Request) {
			key := r.URL.Query().Get("key")
			view, err := gee.GetFromCache(key)
			if err != nil {
				http.Error(w, err.Error(), http.StatusInternalServerError)
				return
			}
			w.Header().Set("Content-Type", "application/octet-stream")
			w.Write(view.GetByteCopy())
		}))
	log.Println("fontend server is running at", apiAddr)
	log.Fatal(http.ListenAndServe(apiAddr[7:], nil))
}

func main() {
	var port int
	var api bool
	flag.IntVar(&port, "port", 8001, "Geecache server port")
	flag.BoolVar(&api, "api", false, "Start a api server?")
	flag.Parse()
	apiAddr := "http://localhost:9999"
	addrMap := map[int]string{
		8001: "http://localhost:8001",
		8002: "http://localhost:8002",
		8003: "http://localhost:8003",
	}
	
	var addrs []string
	for _, v := range addrMap {
		addrs = append(addrs, v)
	}
	
	gee := createGroup()
	if api {
		go startAPIServer(apiAddr, gee)
	}
	startCacheServer(addrMap[port], []string(addrs), gee)
}
```

测试结果：

![image.png](https://www.misaka19327.cc/static/img/4d38a9acddb5ec8782360a2a24bb77d5.image.png)

> 注意不要让它跑在协程下，会出问题。