设计GoAPI的管道使用原则

管道是并发安全的队列，用于在Go的轻量级线程(Go协程)之间安全地传递消息。总的来讲，这些原语是Go语言中最为称道的特色功能之一。这种消息传递范式使得开发者可以以易于理解的语义和控制流来协调管理多线程并发任务，而这胜过使用回调函数或者共享内存。

网站建设哪家好，找创新互联！专注于网页设计、网站建设、微信开发、微信小程序、集团企业网站建设等服务项目。为回馈新老客户创新互联还提供了正蓝免费建站欢迎大家使用！

即使管道如此强大，在公有的API中却不常见。例如，我梳理过Go的标准库，在145个包中有超过6000个公有的API。在这上千个API中，去重后，只有5个用到了管道。

在公有的API中使用管道时，如何折衷考虑和取舍，缺乏指导。“共有API”，我是指“任何实现者和使用者是不同的两个人的编程接口”。这篇文章会深入讲解，为如何在共有API中使用管道，提供一系列的原则和解释。一些特例会在本章末尾讨论。

原则 #1

API应该声明管道的方向性。

例子

time.After

 
 
    
  
  
  1. func After(d Duration) <-chan Time 
    2.

signal.Notify

 
 
    
  
  
  1. func Notify(c chan<- os.Signal, sig ...os.Signal) 
    2.

尽管并不常用，Go允许指定一个管道的方向性。语言规范这么写：

可选的<-操作符指定了管道的方向，发送或接收。如果没有指定方向，那么管道就是双向的。

关键在于API签名中的方向操作符会被编译器强制检查

 
 
    
  
  
  1. t := time.After(time.Second)  
    2. 
  
  
  2. t <- time.Now()  // 会编译失败(send to receive-only type <-chan Time) 
    3.

除了能够被编译器强制检查安全性，方向操作符还能帮助API使用者理解数据的流动方向——只需要看一下类型签名即可。

原则 #2

向一个管道发送无界数据流的API必须写文档解释清楚在消费者消费不及时时API的行为。

例子

time.NewTicker

 
 
    
  
  
  1. // NewTicker returns a new Ticker containing a channel that will send the  
    2. 
  
  
  2. // time with a period specified by the duration argument.  
    3. 
  
  
  3. // It adjusts the intervals or drops ticks to make up for slow receivers.  
    4. 
  
  
  4. // ...  
    5. 
  
  
  5. func NewTicker(d Duration) *Ticker {  
    6. 
  
  
  6.     ...  
    7. 
  
  
  7. } 
    8.

signal.Notify

 
 
    
  
  
  1. // Notify causes package signal to relay incoming signals to c.  
    2. 
  
  
  2. // ...  
    3. 
  
  
  3. // Package signal will not block sending to c  
    4. 
  
  
  4. // ...  
    5. 
  
  
  5.    
    6. 
  
  
  6. func Notify(c chan<- os.Signal, sig ...os.Signal) { 
    7.

ssh.Conn.OpenChannel

 
 
    
  
  
  1. // OpenChannel tries to open an channel.  
    2. 
  
  
  2. // ...  
    3. 
  
  
  3. // On success it returns the SSH Channel and a Go channel for  
    4. 
  
  
  4. // incoming, out-of-band requests. The Go channel must be serviced, or  
    5. 
  
  
  5. // the connection will hang.  
    6. 
  
  
  6.    
    7. 
  
  
  7. OpenChannel(name string, data []byte) (Channel, <-chan *Request, error) 
    8.

当一个API向一个管道发送无界数据流时，在实现API时面临的问题是如果向管道发送数据会阻塞怎么办。阻塞的原因可能是管道已经满了或者管道是无缓冲的，没有go协程准备好接收数据。针对不同的场景要选择合适的行为，但是每个场景必须作出选择。例如，ssh包选择了阻塞，并且文档写明如果你不接受数据，连接就会被卡住。signal.Notify 和 time.Tick选择不阻塞，直接丢弃数据。

不足的是，Go本身并没有从类型或函数签名角度提供方法指定默认行为。作为API的设计者，你必须在文档中写明行为，不然其行为就是不定的。然而，多数情况下我们都是API的使用者而不是设计者，所以我们可以反过来记这个原则，反过来就是一条警告信息：

对于通过一个管道向一个慢速的消费者发送无界数据的API，在没有通读API的文档或者实现源码之前，你不能确定API的行为。

原则 #3

向一个管道发送有界数据，同时这个管道是作为参数传递进来的API，必须用文档写明对于慢速消费者的行为。

不好的例子

rpc.Client.Go

 
 
    
  
  
  1. func (client *Client) Go(serviceMethod string,  
    2. 
  
  
  2.                          args interface{},  
    3. 
  
  
  3.                          reply interface{},  
    4. 
  
  
  4.                          done chan *Call  
    5. 
  
  
  5.                          ) *Call 
    6.

这个原则和第二个原则类似，不同点在于这个原则用于发送有界数据的API。不幸的是，在标准库中没有很好的例子。标准库中唯一的API就是rpc.Client.Go，但它违背了我们的原则。文档上这么写：

Go异步的调用这个函数。它会返回代表着调用的Call数据结构。在调用完成时，done管道会通过返回同一个Call对象来触发。如果done是空的，Go会分配一个新的管道；如果不空，done必须是有缓冲的，不然Go就会崩溃。

Go发送了有界数据（只有1，当远程调用结束时）。但是注意到，由于管道是被当作参数传递到函数中的，所以它仍然存在慢速消费者问题。即使你必须传一个带缓冲的管道进来，如果管道已满，向这个管道发送数据仍然可能会阻塞。文档并没有定义这种场景下的行为。需要我们来读读源码了：

src/pkg/net/rpc/client.go

 
 
    
  
  
  1. func (call *Call) done() {  
    2. 
  
  
  2.      select {  
    3. 
  
  
  3.      case call.Done <- call:  
    4. 
  
  
  4.      // ok  
    5. 
  
  
  5.      default:  
    6. 
  
  
  6.      // We don't want to block here.  It is the caller's responsibility to make  
    7. 
  
  
  7.          // sure the channel has enough buffer space. See comment in Go().  
    8. 
  
  
  8.          if debugLog {  
    9. 
  
  
  9.              log.Println("rpc: discarding Call reply due to insufficient Done chan capacity")  
    10. 
  
  
  10.          }  
    11. 
  
  
  11.      }  
    12. 
  
  
  12. } 
    13.

噢！如果done管道没有合适的缓冲，RPC的响应可能丢失了。

原则 #4

向一个管道发送无界数据流的API应该接受管道作为参数，而不是返回一个新的管道。

例子

signal.Notify

 
 
    
  
  
  1. func Notify(c chan<- os.Signal, sig ...os.Signal) 
    2.

ssh.NewClient

 
 
    
  
  
  1. func NewClient(c Conn, chans <-chan NewChannel, reqs <-chan *Request) *Client 
    2.

当我第一次看到signal.Notify这个API时，我很疑惑，“为什么它接收一个管道作为输入而不是直接返回一个管道给我用？”“使用这个API需要调用方分配一个管道，难道API就不能替我们做么，像下面这样？”

 
 
    
  
  
  1. func Notify(sig ...os.Signal) <-chan os.Signal 
    2.

文档帮助我们理解为什么这不是好的选择：

signal包向c发送数据时并不会阻塞：调用方必须保证c有足够的缓冲空间来跟得上潜在的信号速度

signal.Notify接收管道作为参数，因为它把缓冲空间的控制权交给了调用方。这使得调用方可以选择，在处理一个信号时，可以安全的忽略多少信号，这需要和缓存这些信号的内存开销作折衷考虑。

缓冲大小的控制在高吞吐系统中尤为重要。设想一个高吞吐的发布订阅系统的这样一个接口：

 
 
    
  
  
  1. func Subscribe(topic string, msgs chan<- Msg) 
    2.

往管道中发送越多的消息，管道同步称为性能瓶颈的可能性越大。由于API允许调用方创建管道，调用方需要考虑缓冲，进而性能可以由调用方控制。这是一种更灵活的设计。

如果仅仅是控制缓冲的大小，我们可能会争论如下的API就足够了：

 
 
    
  
  
  1. func Notify(sig ...os.Signal, bufSize int) <-chan os.Signal 
    2.

这样设计，管道作为参数还是必须的，因为这样允许调用方使用一个管道动态的处理不同类型的信号。这样设计为调用方提供了更多的程序结构和性能上的灵活性。作为一个假想实验，让我们用Subscribe API来构建需求。订阅newcustomer管道，并对于每一条消息，为消费者订阅其主题。如果API允许我们传递接收管道，我们可以这样写：

 
 
    
  
  
  1. msgs := make(chan Msg, 128)  
    2. 
  
  
  2.    
    3. 
  
  
  3. Subscribe("newcustomer", msgs)  
    4. 
  
  
  4. for m := range msgs {  
    5. 
  
  
  5.     switch m.Topic {  
    6. 
  
  
  6.     case "newcustomer":  
    7. 
  
  
  7.         Subscribe(msg.Payload, msgs)  
    8. 
  
  
  8.     default:  
    9. 
  
  
  9.         handleCustomerMessage(m)  
    10. 
  
  
  10. } 
    11.

但是，如果管道被返回了，调用方不得不为每一个订阅启动一个单独的go协程。这在任何复用场景都会带来额外的内存和同步开销:

 
 
    
  
  
  1. for m := range Subscribe("newcustomer") {  
    2. 
  
  
  2.     go subCustomer(m.Payload)  
    3. 
  
  
  3. }  
    4. 
  
  
  4.    
    5. 
  
  
  5. func subCustomer(topic string) {  
    6. 
  
  
  6.     for m := range Subscribe(topic) {  
    7. 
  
  
  7.         handleCustomerMessage(m)  
    8. 
  
  
  8.     }  
    9. 
  
  
  9. } 
    10.

原则 #5

发送有界数据的API可以通过返回一个合适大小缓冲的管道来达到目的。

例子:

http.CloseNotifier

 
 
    
  
  
  1. type CloseNotifier interface {  
    2. 
  
  
  2.         // CloseNotify returns a channel that receives a single value  
    3. 
  
  
  3.         // when the client connection has gone away.  
    4. 
  
  
  4.         CloseNotify() <-chan bool  
    5. 
  
  
  5. } 
    6.

time.After

 
 
    
  
  
  1. func After(d Duration) <-chan Time 
    2.

当API向一个管道发送有界数据时，可以返回一个拥有容纳全部数据的缓冲空间的管道。这个要返回的管道的方向性标识保证了调用方必须遵守约定。CloseNotify 和After返回的管道 都利用了这一点。

同时，需要注意到，通过允许调用方传递一个管道来接收数据，这些调用可能会更灵活。但需要处理当管道满了的时候（原则3）。例如，另外一个可选的，更灵活的CloseNotifier：

 
 
    
  
  
  1. type CloseNotifier interface {  
    2. 
  
  
  2.         // CloseNotify sends a single value with the ResponseWriter whose  
    3. 
  
  
  3.         // underlying connection has gone away.  
    4. 
  
  
  4.         CloseNotify(chan<- http.ResponseWriter)  
    5. 
  
  
  5. } 
    6.

但是这种额外的灵活性带来的开销并不值得关注，因为单一的调用方很少会同时等待多个关闭通知。毕竟，关闭通知只有在某个连接上下文内才有效。不同的连接一般都是相互独立的。

特例

一些API打破了我们的原则，需要仔细分析。

原则 #1 的特例

API需要声明管的方向性。

例子

rpc.Client.Go

传过来的done管道没有方向性标识符：

 
 
    
  
  
  1. func (client *Client) Go(serviceMethod string,  
    2. 
  
  
  2.                          args interface{},  
    3. 
  
  
  3.                          reply interface{},  
    4. 
  
  
  4.                          done chan *Call  
    5. 
  
  
  5.                          ) *Call 
    6.

直观上看，这样做是因为done管道是作为Call结构体的一部分返回的。

 
 
    
  
  
  1. type Call struct {  
    2. 
  
  
  2.         // ...  
    3. 
  
  
  3.         Done          chan *Call  // Strobes when call is complete.  
    4. 
  
  
  4. } 
    5.

这种灵活性是需要的，这样允许在你传nil时分配一个done管道出来。如果坚持原则1，就需要从Call结构中去除done并且声明两个函数：

 
 
    
  
  
  1. func (c *Client) Go(method string,  
    2. 
  
  
  2.                     args interface{},  
    3. 
  
  
  3.                     reply interface{}  
    4. 
  
  
  4.                     ) (*Call, <-chan *Call)  
    5. 
  
  
  5.    
    6. 
  
  
  6. func (c *Client) GoEx(method string,  
    7. 
  
  
  7.                       args interface{},  
    8. 
  
  
  8.                       reply interface{},  
    9. 
  
  
  9.                       done chan<- *Call  
    10. 
  
  
  10.                       ) *Call 
    11.

原则 #4 的特例

向管道发送无界数据流的API需要接收管道作为参数，而不是返回一个新的管道。

例子

go.crypto/ssh

 
 
    
  
  
  1. func NewClientConn(c net.Conn, addr string, config *ClientConfig)  
    2. 
  
  
  2.     (Conn, <-chan NewChannel, <-chan *Request, error) 
    3.

time.Tick

 
 
    
  
  
  1. func Tick(d Duration) <-chan Time 
    2.

go.crypto/ssh包几乎在所有的地方都返回了无界的数据流管道。ssh.NewClientConn只是其中的一个。给调用者更多控制权和灵活性的API应该是这样：

 
 
    
  
  
  1. func NewClientConn(c net.Conn,  
    2. 
  
  
  2.                    addr string,  
    3. 
  
  
  3.                    config *ClientConfig,  
    4. 
  
  
  4.                    channels chan<- NewChannel,  
    5. 
  
  
  5.                    reqs chan<- *Request  
    6. 
  
  
  6.                    ) (Conn, error) 
    7.

time.Tick也违反了这个原则，但是易于理解。我们很少会创建非常多的计时器，通常都是独立的处理不同的计时器。这个例子中缓冲也没太大意义。

第二部分：那些原本可能使用的管道

这篇文章是一篇长文，所以我准备分成两部分讲。接下来会提很多问题，为什么标准库中可以使用管的地方却没有用管道。例如，http.Serve 返回了一个永不结束的等待被处理的请求流，为什么用了回调函数而不是将这些请求发送到一个处理管道中？第二部分会介绍更多！

原文链接： Alan Shreve   翻译： 伯乐在线 - Codefor

译文链接： http://blog.jobbole.com/73700/

网页名称：设计GoAPI的管道使用原则
本文链接：http://www.shufengxianlan.com/qtweb/news36/484936.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

用户体验知识

分类信息网站

网站空间　　 　成都网页设计　　 　响应式网站　　 　整合营销　　 　关键词排名优化　　 　网络推广外包　　 　都江堰做网站　　 　成都网络营销　　 　微信小程序开发　　 　高端网站建设　　 　成都酒店服定制　　 　网站建设方案　　 　眉山服务器租用　　 　四川胜锦安防　　 　成都网站建设　　 　新华建筑装饰　　 　乐山电信机房　　 　产品包装设计　　 　户外广告设计　　 　达州托管服务器