对于程序及服务的控制，本质上而言就是正确的启动，并可控的停止或退出。在go语言中，其实就是程序安全退出、服务控制两个方面。核心在于系统信号获取、Go Concurrency Patterns、以及基本的代码封装
程序安全退出
执行代码非安全写法
在代码部署后，我们可能因为服务配置发生变化或其他各种原因，需要将服务停止或者重启。通常就是for循环阻塞，运行代码，然后通过control+C或者kill来强制退出。代码如下：
//file svc1.go
package main
import (
"fmt"
"time"
)
//当接收到Control+c,kill -1,kill -2,kill -9 均无法正常执行defer函数
func main() {
fmt.Println("application is begin.")
//以下代码不会执行
defer fmt.Println("application is end.")
for {
time.Sleep(time.Second)
fmt.Println("application is running.")
}
}
这种方式简单粗暴，很多时候基本也够用。但这种情况下，程序是不会执行defer的代码的，因此无法正确处理结束操作，会丢失一些很关键的日志记录、消息通知，非常不安全的。这时，需要引入一个简单的框架，来执行退出
执行代码的基本：信号拦截
由于go语言中的关键字go很好用，通过标准库，我们可以很优雅的实现退出信号的拦截：
//file svc2.go
package main
import (
"fmt"
"time"
"os/signal"
"os"
)
//当接收到Control+c,kill -1,kill -2 的时候,都可以执行执行defer函数
// kill -9依然不会正常退出。
func main() {
fmt.Println("application is begin.")
//当程序接受到退出信号的时候,将会执行
defer fmt.Println("application is end.")
//协程启动的匿名函数，模拟业务代码
go func(){
for {
time.Sleep(time.Second)
fmt.Println("application is running.")
}
}()
//捕获程序退出信号
msgChan:=make(chan os.Signal,1)
signal.Notify(msgChan,os.Interrupt,os.Kill)
<-msgChan
}
此时，我们实现了程序退出时的信号拦截，补充业务代码就可以了。但实际业务逻辑至少涉及到初始化、业务处理、退出三大块，代码量多了，会显得比较混乱，这就需要规范代码的结构。
执行代码的改进：信号拦截包装器
考虑上述情况，我们将正常的程序定义为：
- Init: 系统初始化，比如识别操作系统、初始化服务发现Consul、Zookeper的agent、数据库连接池等。
- Start:程序主要业务逻辑，包括但不限于数据加载、服务注册、具体业务响应。
- Stop: 程序退出时的业务，主要包括内存数据存储、服务注销。
基于这个定义，之前的svc2.go仅保留业务代码的情况下，可以这样改写：
//file svc3.go
package main
import (
"fmt"
"time"
"study1/svc"
)
type Program struct {}
func (p *Program) Start()error {
fmt.Println("application is begin.")
//必须非阻塞，因此通过协程封装。
go func(){
for {
time.Sleep(time.Second)
fmt.Println("application is running.")
}
}()
return nil
}
func (p *Program)Init()error{
//just demon,do nothing
return nil
}
func (p *Program) Stop() error {
fmt.Println("application is end.")
return nil
}
//当接收到Control+C,kill -1,kill -2 的时候,都可执行defer函数
// kill -9依然不会正常退出。
func main() {
p:=&Program{}
svc.Run(p)
}
上诉代码中的Program的Init、Start、Stop事实上是实现了相关的接口定义，该接口在svc包中，被Run方法使用。代码如下：
//file svc.go
package svc
import (
"os"
"os/signal"
)
//标准程序执行和退出的执行接口,运行程序要实现接口定义的方法
type Service interface {
Init() error
//当程序启动运行的时候,需要执行的代码。不得阻塞。
Start() error
//程序退出的时候,需要执行的代码。不得阻塞。
Stop() error
}
var msgChan = make(chan os.Signal, 1)
// 程序运行、退出的包装容器,主程序直接调用。
func Run(service Service) error {
if err := service.Init(); err != nil {
return err
}
if err := service.Start(); err != nil {
return err
}
signal.Notify(msgChan, os.Interrupt, os.Kill)
<-msgChan
return service.Stop()
}
// 通常不需要调用,特殊情况下,在程序内其他模块中，需要通知程序退出才会使用。
func Interrupt(){
msgChan<-os.Interrupt
}
这段代码中，svg包的Run只会被唯一的main调用。为了支持其他退出模式，比如用户敲入字符命令的退出，因此加入了“后门”——Interrupt方法。后边会有具体的使用案例。由于一个进程只会有一个svg.Service的实例，通常情况下足以使用
在网络应用，可能会有更复杂的情况，我们需要考虑：
- 程序启动
- 程序不退出的情况下，多服务启动、并行运行与退出
- 程序退出，并清理运行中的服务
可以做一个简单的Demon程序，来实现以上三点，其中，程序退出可以通过键盘输入命令，也可以Control+D。基于golang1.7，我们可以采用以下知识点：
- 利用cancelContext来控制服务的退出
- 利用之前实现的svc来实现程序的安全退出
- 利用os.Stdin来获取键盘输入命令来模拟服务加载与退出的消息驱动。实际可能是网络rpc或http数据触发
golang1.7的context包
我们知道，当通道chan被close之后，任何<-chan都会得到立即执行。如果不清楚，可以查阅相关资料或写个测试代码，最好研读
golang的官方资料：https://blog.golang.org/pipelines
利用这个特征，我们可以通过golang1.7标准库新增的context包，通过注入的方式来实现全局或单个服务的控制。
context中定义了Context接口，我们通过几种不同的方法来获取不同的实现。包括：
WithDeadline\WithTimeout，获取到基于时间相关的退出句柄，以控制服务退出。
WithCancel，获取到cancelFunc句柄，以控制服务的退出。
WithValue，获取到k-v键值对，实现类似于session信息保存的业务支持。
Background\TODO，conext的根，通常作为以上三种方法的parent。
context包不是新东西，2014年就已经在google.org/x/net中，作为扩展库被很多开源项目使用（GIN、IRIS等等）。其CSP的应用方式非常值得进一步研读。
捕获键盘输入
通过os.stdin来获取键盘输入，其解析需要bufilo.Reader来协助处理。通常代码格式就是：
//... //初始化键盘读取 reader:=bufilo.NewReader(os.Stdin) //阻塞，直到敲入Enter键 input, _, _ := reader.ReadLine() command:=string(input) //...
示例代码
有了这两个概念之后，就可以很方便的实现一个简单的微服务加载、退出的框架。参考代码如下：
//file svc4.go
package main
import (
"bufio"
"context"
"errors"
"fmt"
"os"
"strings"
"study1/svc"
"sync"
"time"
)
type Program struct {
ctx context.Context
exitFunc context.CancelFunc
cancelFunc map[string]context.CancelFunc
wg WaitGroupWrapper
}
func main() {
p := &Program{
cancelFunc: make(map[string]context.CancelFunc),
}
p.ctx, p.exitFunc = context.WithCancel(context.Background())
svc.Run(p)
}
func (p *Program) Init() error {
//just demon,do nothing
return nil
}
func (p *Program) Start() error {
fmt.Println("本程序将会根据输入,启动或终止服务。")
reader := bufio.NewReader(os.Stdin)
go func() {
for {
fmt.Println("程序退出命令:exit;服务启动命令:<start||s>-[name];服务停止命令:<cancel||c>-[name]。请注意大小写!")
input, _, _ := reader.ReadLine()
command := string(input)
switch command {
case "exit":
goto OutLoop
default:
command, name, err := splitInput(input)
if err != nil {
fmt.Println(err)
continue
}
switch command {
case "start", "s":
newctx, cancelFunc := context.WithCancel(p.ctx)
p.cancelFunc[name] = cancelFunc
p.wg.Wrap(func() {
Func(newctx, name)
})
case "cancel", "c":
cancelFunc, founded := p.cancelFunc[name]
if founded {
cancelFunc()
}
}
}
}
OutLoop:
//由于程序退出被Run的os.Notify阻塞，因此调用以下方法通知退出代码执行。
svc.Interrupt()
}()
return nil
}
func (p *Program) Stop() error {
p.exitFunc()
p.wg.Wait()
fmt.Println("所有服务终止,程序退出!")
return nil
}
//用来转换输入字符串为输入命令
func splitInput(input []byte) (command, name string, err error) {
line := string(input)
strs := strings.Split(line, "-")
if strs == nil || len(strs) != 2 {
err = errors.New("输入不符合规则。")
return
}
command = strs[0]
name = strs[1]
return
}
// 一个简单的循环方法,模拟被加载、释放的微服务
func Func(ctx context.Context, name string) {
for {
select {
case <-ctx.Done():
goto OutLoop
case <-time.Tick(time.Second * 2):
fmt.Printf("%s is running.\n", name)
}
}
OutLoop:
fmt.Printf("%s is end.\n", name)
}
//WaitGroup封装结构
type WaitGroupWrapper struct {
sync.WaitGroup
}
func (w *WaitGroupWrapper) Wrap(f func()) {
w.Add(1)
go func() {
f()
w.Done()
}()
}
代码运行的时候，可以：
- 通过输入”s-“或者”start-“+服务名，来启动一个服务
- 用”c-“或”cancel-“+服务名，来退出指定服务
- 可以用 “exit”或者Control+C、kill来退出程序（除了kill -9）。
在此基础上，还可以利用context包实现服务超时退出，利用for range限制服务数量，利用HTTP实现微服务RestFUL信息驱动。由于扩展之后代码增加，显得冗余，这里不再赘述。
转自：http://blog.csdn.net/qq_26981997/article/details/52275456
