看到一段代码不甚明白
package main
import (
"fmt"
"github.com/gin-gonic/gin"
"golang.org/x/sync/errgroup"
"os"
"os/signal"
"sync/atomic"
"syscall"
"time"
_ "yj-app/app/controller/router"
"yj-app/app/service/middleware/sessions"
"yj-app/app/service/middleware/sessions/memstore"
"yj-app/app/yjgframe/cfg"
_ "yj-app/app/yjgframe/cron"
"yj-app/app/yjgframe/server"
)
var (
g errgroup.Group
)
// @title 云捷GO 自动生成API文档
// @version 1.0
// @description 生成文档请在调试模式下进行<a href="/tool/swagger?a=r">重新生成文档</a>
// @host localhost
// @BasePath /api
func main() {
gin.SetMode("debug")
config := cfg.Instance()
if config == nil {
fmt.Printf("参数错误")
return
}
//后台服务状态
adminStatus := config.Status.Admin
//api服务状态
apiStatus := config.Status.Api
if adminStatus {
store := memstore.NewStore([]byte("secret"))
admin := server.New("admin", config.Admin.Address, gin.Logger(), sessions.Sessions("mysession", store))
admin.Template("template").Static(config.Admin.ServerRoot)
admin.Start(g)
}
if apiStatus {
api := server.New("api", config.Api.Address, gin.Recovery(), gin.Logger())
api.Start(g)
}
if err := g.Wait(); err != nil {
fmt.Println(err.Error())
}
var state int32 = 1
sc := make(chan os.Signal, 1)
signal.Notify(sc, syscall.SIGHUP, syscall.SIGINT, syscall.SIGTERM, syscall.SIGQUIT)
EXIT:
for {
sig := <-sc
fmt.Println("获取到信号[%s]", sig.String())
switch sig {
case syscall.SIGQUIT, syscall.SIGTERM, syscall.SIGINT:
atomic.StoreInt32(&state, 0)
break EXIT
case syscall.SIGHUP:
default:
break EXIT
}
}
fmt.Println("服务退出")
time.Sleep(time.Second)
os.Exit(int(atomic.LoadInt32(&state)))
}
下面搜索结果
函数声明为：
func Notify(c chan<- os.Signal, sig ...os.Signal)官方描述：
Notify函数让signal包将输入信号转发到c。如果没有列出要传递的信号，会将所有输入信号传递到c；否则只传递列出的输入信号。
signal包不会为了向c发送信息而阻塞（就是说如果发送时c阻塞了，signal包会直接放弃）：调用者应该保证c有足够的缓存空间可以跟上期望的信号频率。对使用单一信号用于通知的通道，缓存为1就足够了。
示例代码：
ch := make(chan os.Signal, 1)
signal.Notify(ch, syscall.SIGHUP, syscall.SIGQUIT, syscall.SIGTERM, syscall.SIGSTOP, syscall.SIGUSR1)
for {
s := <-ch
switch s {
case syscall.SIGQUIT:
log.Infof("SIGSTOP")
return
case syscall.SIGSTOP:
log.Infof("SIGSTOP")
return
case syscall.SIGHUP:
log.Infof("SIGHUP")
return
case syscall.SIGKILL:
log.Infof("SIGKILL")
return
case syscall.SIGUSR1:
log.Infof("SIGUSR1")
return
default:
log.Infof("default")
return
}
}以上代码告诉 signal ，将对应的信号通知 ch，然后在 for 循环中针对不同信号做不同的处理， for 循环为死循环。
goto
goto语句可以无条件地转移到过程中指定的行。
通常与条件语句配合使用。可用来实现条件转移， 构成循环，跳出循环体等功能。
在结构化程序设计中一般不主张使用goto语句， 以免造成程序流程的混乱
goto对应(标签)既可以定义在for循环前面,也可以定义在for循环后面，当跳转到标签地方时，继续执行标签下面的代码。
func main() {
// 放在for前面，此例会一直循环下去
Loop:
fmt.Println("test")
for a:=0;a<5;a++{
fmt.Println(a)
if a>3{
goto Loop
}
}
}
func main() {
for a:=0;a<5;a++{
fmt.Println(a)
if a>3{
goto Loop
}
}
Loop: //放在for后边
fmt.Println("test")
}
break
func main() {
Loop:
for j:=0;j<3;j++{
fmt.Println(j)
for a:=0;a<5;a++{
fmt.Println(a)
if a>3{
break Loop
}
}
}
}
//在没有使用loop标签的时候break只是跳出了第一层for循环
//使用标签后跳出到指定的标签,break只能跳出到之前，如果将Loop标签放在后边则会报错
//break标签只能用于for循环，跳出后不再执行标签对应的for循环
continue
continue和标签的使用类似于break，这里不再详述
总结
goto语句本身就是做跳转用的，而break和continue是配合for使用的。所以goto的使用不限于for，通常与条件语句配合使用
在for循环中break和continue可以配合标签使用。参考地址：