我要提问
- 关于
panic
的搜索结果
回答
1、编译执行下面代码会出现什么?
package main
var(
size :=1024
max_size = size*2
)
func main() {
println(size,max_size)
}
解析 考点:变量简短模式 变量简短模式限制： - 定义变量同时显式初始化 - 不能提供数据类型 - 只能在函数内部使用
结果：
syntax error: unexpected :=
2、下面函数有什么问题？
package main
const cl = 100
var bl = 123
func main() {
println(&bl,bl)
println(&cl,cl)
}
解析 考点:常量 常量不同于变量的在运行期分配内存，常量通常会被编译器在预处理阶段直接展开，作为指令数据使用，
cannot take the address of cl
3、编译执行下面代码会出现什么?
package main
func main() {
for i:=0;i<10 ;i++ {
loop:
println(i)
}
goto loop
}
解析 考点：goto goto不能跳转到其他函数或者内层代码
goto loop jumps into block starting at
4、编译执行下面代码会出现什么?
package main
import "fmt"
func main() {
type MyInt1 int
type MyInt2 = int
var i int =9
var i1 MyInt1 = i
var i2 MyInt2 = i
fmt.Println(i1,i2)
}
解析 考点：Go 1.9 新特性 Type Alias 基于一个类型创建一个新类型，称之为defintion；基于一个类型创建一个别名，称之为alias。 MyInt1为称之为defintion，虽然底层类型为int类型，但是不能直接赋值，需要强转； MyInt2称之为alias，可以直接赋值。
结果:
cannot use i (type int) as type MyInt1 in assignment
5、编译执行下面代码会出现什么?
package main
import "fmt"
type User struct {
}
type MyUser1 User
type MyUser2 = User
func (i MyUser1) m1(){
fmt.Println("MyUser1.m1")
}
func (i User) m2(){
fmt.Println("User.m2")
}
func main() {
var i1 MyUser1
var i2 MyUser2
i1.m1()
i2.m2()
}
解析 考点：Go 1.9 新特性 Type Alias 因为MyUser2完全等价于User，所以具有其所有的方法，并且其中一个新增了方法，另外一个也会有。 但是
i1.m2()
是不能执行的，因为MyUser1没有定义该方法。 结果:
MyUser1.m1
User.m2
6、编译执行下面代码会出现什么?
package main
import "fmt"
type T1 struct {
}
func (t T1) m1(){
fmt.Println("T1.m1")
}
type T2 = T1
type MyStruct struct {
T1
T2
}
func main() {
my:=MyStruct{}
my.m1()
}
解析 考点：**Go 1.9 新特性 Type Alias ** 是不能正常编译的,异常：
ambiguous selector my.m1
结果不限于方法，字段也也一样；也不限于type alias，type defintion也是一样的，只要有重复的方法、字段，就会有这种提示，因为不知道该选择哪个。 改为:
my.T1.m1()
my.T2.m1()
type alias的定义，本质上是一样的类型，只是起了一个别名，源类型怎么用，别名类型也怎么用，保留源类型的所有方法、字段等。
7、编译执行下面代码会出现什么?
package main
import (
"errors"
"fmt"
)
var ErrDidNotWork = errors.New("did not work")
func DoTheThing(reallyDoIt bool) (err error) {
if reallyDoIt {
result, err := tryTheThing()
if err != nil || result != "it worked" {
err = ErrDidNotWork
}
}
return err
}
func tryTheThing() (string,error) {
return "",ErrDidNotWork
}
func main() {
fmt.Println(DoTheThing(true))
fmt.Println(DoTheThing(false))
}
解析 考点：变量作用域 因为 if 语句块内的 err 变量会遮罩函数作用域内的 err 变量，结果：
<nil>
<nil>
改为：
func DoTheThing(reallyDoIt bool) (err error) {
var result string
if reallyDoIt {
result, err = tryTheThing()
if err != nil || result != "it worked" {
err = ErrDidNotWork
}
}
return err
}
8、编译执行下面代码会出现什么?
package main
func test() []func() {
var funs []func()
for i:=0;i<2 ;i++ {
funs = append(funs, func() {
println(&i,i)
})
}
return funs
}
func main(){
funs:=test()
for _,f:=range funs{
f()
}
}
解析 考点：闭包延迟求值 for循环复用局部变量i，每一次放入匿名函数的应用都是想一个变量。 结果：
0xc042046000 2
0xc042046000 2
如果想不一样可以改为：
func test() []func() {
var funs []func()
for i:=0;i<2 ;i++ {
x:=i
funs = append(funs, func() {
println(&x,x)
})
}
return funs
}
9、编译执行下面代码会出现什么?
package main
func test(x int) (func(),func()) {
return func() {
println(x)
x+=10
}, func() {
println(x)
}
}
func main() {
a,b:=test(100)
a()
b()
}
解析 考点：闭包引用相同变量 结果：
100
110
10、编译执行下面代码会出现什么?
package main
import (
"fmt"
)
func main() {
defer func() {
if err:=recover();err!=nil{
fmt.Println(err)
}else {
fmt.Println("fatal")
}
}()
defer func() {
panic("defer panic")
}()
panic("panic")
}
解析 考点：panic仅有最后一个可以被revover捕获 触发panic("panic")后顺序执行defer，但是defer中还有一个panic，所以覆盖了之前的panic("panic")
defer panic
回答
快速使用
在您开始之前，您需要注册阿里云账号并获取您的凭证。下文将以创建一个流程，发起一次执行并获取执行详情为例展示如何使用 Go SDK 调用 Serverless 工作流服务。
请求方式
package main
import ( "fmt" "time"
"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
"github.com/aliyun/alibaba-cloud-sdk-go/services/fnf"
)
var ( flowDefinitionType = "FDL" flowName = "xxx" flowDefinition = xxx flowDescription = "some descriptions" roleArn = "acs:ram::${Your_Account_ID}:${Your_Role}" executionName = "xxx" )
// CreateFlow ... func CreateFlow(cli *fnf.Client) (*fnf.CreateFlowResponse, error) { request := fnf.CreateCreateFlowRequest() request.Name = flowName request.Definition = flowDefinition request.Description = flowDescription request.Type = flowDefinitionType request.RoleArn = roleArn return cli.CreateFlow(request) }
// StartExecution ... func StartExecution(cli *fnf.Client) (*fnf.StartExecutionResponse, error) { request := fnf.CreateStartExecutionRequest() request.FlowName = flowName request.ExecutionName = executionName return cli.StartExecution(request) }
// DescribeExecution ... func DescribeExecution(cli *fnf.Client) (*fnf.DescribeExecutionResponse, error) { request := fnf.CreateDescribeExecutionRequest() request.FlowName = flowName request.ExecutionName = executionName return cli.DescribeExecution(request) }
// GetExecutionHistory ... func GetExecutionHistory(cli *fnf.Client) (*fnf.GetExecutionHistoryResponse, error) { request := fnf.CreateGetExecutionHistoryRequest() // request.Limit and request.NextToken can set here. For easy demo, we passed. request.FlowName = flowName request.ExecutionName = executionName return cli.GetExecutionHistory(request) }
创建客户端并利用上述函数发起一系列调用 说明 如果您需要不加改造进行调试的话，请将下述函数与上述请求方式代码块置于同一个文件中，避免在 import 时报错。
func main() { fnfCli, err := fnf.NewClientWithAccessKey("cn-hangzhou", "AccessID", "AccessKey") if err != nil { panic(err) } // Create a flow _, err = CreateFlow(fnfCli) if err != nil { panic(err) } // StartExecution _, err = StartExecution(fnfCli) if err != nil { panic(err) } time.Sleep(time.Second) // DescribeExecution desResp, err := DescribeExecution(fnfCli) if err != nil { panic(err) } fmt.Println(fmt.Sprintf("%s status: %s", desResp.Name, desResp.Status)) // GetExecutionHistory _, err = GetExecutionHistory(fnfCli) if err != nil { panic(err) } }
回答
本文介绍使用 Go SDK 的详细流程，包括环境要求、安装和快速使用三部分。
环境要求 您的系统需要达到环境要求，例如安装了 1.10.x 或以上版本的 Go 环境。
安装 使用 go get 下载安装 Go SDK 。
$ go get -u github.com/aliyun/alibaba-cloud-sdk-go/sdk 如果您使用了 glide 管理依赖，您也可以使用 glide 来安装 Alibaba Cloud SDK for Go。
$ glide get github.com/aliyun/alibaba-cloud-sdk-go 另外，Alibaba Cloud SDK for Go 也会发布在 https://develop.aliyun.com/tools/sdk#/go。
快速使用 在您开始之前，您需要注册阿里云账号并获取您的凭证。下文将以创建一个流程，发起一次执行并获取执行详情为例展示如何使用 Go SDK 调用 Serverless 工作流服务。
请求方式
package main
import ( "fmt" "time"
"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
"github.com/aliyun/alibaba-cloud-sdk-go/services/fnf"
)
var ( flowDefinitionType = "FDL" flowName = "xxx" flowDefinition = xxx flowDescription = "some descriptions" roleArn = "acs:ram::${Your_Account_ID}:${Your_Role}" executionName = "xxx" )
// CreateFlow ... func CreateFlow(cli *fnf.Client) (*fnf.CreateFlowResponse, error) { request := fnf.CreateCreateFlowRequest() request.Name = flowName request.Definition = flowDefinition request.Description = flowDescription request.Type = flowDefinitionType request.RoleArn = roleArn return cli.CreateFlow(request) }
// StartExecution ... func StartExecution(cli *fnf.Client) (*fnf.StartExecutionResponse, error) { request := fnf.CreateStartExecutionRequest() request.FlowName = flowName request.ExecutionName = executionName return cli.StartExecution(request) }
// DescribeExecution ... func DescribeExecution(cli *fnf.Client) (*fnf.DescribeExecutionResponse, error) { request := fnf.CreateDescribeExecutionRequest() request.FlowName = flowName request.ExecutionName = executionName return cli.DescribeExecution(request) }
// GetExecutionHistory ... func GetExecutionHistory(cli *fnf.Client) (*fnf.GetExecutionHistoryResponse, error) { request := fnf.CreateGetExecutionHistoryRequest() // request.Limit and request.NextToken can set here. For easy demo, we passed. request.FlowName = flowName request.ExecutionName = executionName return cli.GetExecutionHistory(request) } 创建客户端并利用上述函数发起一系列调用
说明 如果您需要不加改造进行调试的话，请将下述函数与上述请求方式代码块置于同一个文件中，避免在 import 时报错。 func main() { fnfCli, err := fnf.NewClientWithAccessKey("cn-hangzhou", "AccessID", "AccessKey") if err != nil { panic(err) } // Create a flow _, err = CreateFlow(fnfCli) if err != nil { panic(err) } // StartExecution _, err = StartExecution(fnfCli) if err != nil { panic(err) } time.Sleep(time.Second) // DescribeExecution desResp, err := DescribeExecution(fnfCli) if err != nil { panic(err) } fmt.Println(fmt.Sprintf("%s status: %s", desResp.Name, desResp.Status)) // GetExecutionHistory _, err = GetExecutionHistory(fnfCli) if err != nil { panic(err) } }
回答
本文介绍使用 Go SDK 的详细流程，包括环境要求、安装和快速使用三部分。
环境要求 您的系统需要达到环境要求，例如安装了 1.10.x 或以上版本的 Go 环境。
安装 使用 go get 下载安装 Go SDK 。
$ go get -u github.com/aliyun/alibaba-cloud-sdk-go/sdk 如果您使用了 glide 管理依赖，您也可以使用 glide 来安装 Alibaba Cloud SDK for Go。
$ glide get github.com/aliyun/alibaba-cloud-sdk-go 另外，Alibaba Cloud SDK for Go 也会发布在 https://develop.aliyun.com/tools/sdk#/go。
快速使用 在您开始之前，您需要注册阿里云账号并获取您的凭证。下文将以创建一个流程，发起一次执行并获取执行详情为例展示如何使用 Go SDK 调用 Serverless 工作流服务。
请求方式
package main
import ( "fmt" "time"
"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
"github.com/aliyun/alibaba-cloud-sdk-go/services/fnf"
)
var ( flowDefinitionType = "FDL" flowName = "xxx" flowDefinition = xxx flowDescription = "some descriptions" roleArn = "acs:ram::${Your_Account_ID}:${Your_Role}" executionName = "xxx" )
// CreateFlow ... func CreateFlow(cli *fnf.Client) (*fnf.CreateFlowResponse, error) { request := fnf.CreateCreateFlowRequest() request.Name = flowName request.Definition = flowDefinition request.Description = flowDescription request.Type = flowDefinitionType request.RoleArn = roleArn return cli.CreateFlow(request) }
// StartExecution ... func StartExecution(cli *fnf.Client) (*fnf.StartExecutionResponse, error) { request := fnf.CreateStartExecutionRequest() request.FlowName = flowName request.ExecutionName = executionName return cli.StartExecution(request) }
// DescribeExecution ... func DescribeExecution(cli *fnf.Client) (*fnf.DescribeExecutionResponse, error) { request := fnf.CreateDescribeExecutionRequest() request.FlowName = flowName request.ExecutionName = executionName return cli.DescribeExecution(request) }
// GetExecutionHistory ... func GetExecutionHistory(cli *fnf.Client) (*fnf.GetExecutionHistoryResponse, error) { request := fnf.CreateGetExecutionHistoryRequest() // request.Limit and request.NextToken can set here. For easy demo, we passed. request.FlowName = flowName request.ExecutionName = executionName return cli.GetExecutionHistory(request) } 创建客户端并利用上述函数发起一系列调用
说明 如果您需要不加改造进行调试的话，请将下述函数与上述请求方式代码块置于同一个文件中，避免在 import 时报错。 func main() { fnfCli, err := fnf.NewClientWithAccessKey("cn-hangzhou", "AccessID", "AccessKey") if err != nil { panic(err) } // Create a flow _, err = CreateFlow(fnfCli) if err != nil { panic(err) } // StartExecution _, err = StartExecution(fnfCli) if err != nil { panic(err) } time.Sleep(time.Second) // DescribeExecution desResp, err := DescribeExecution(fnfCli) if err != nil { panic(err) } fmt.Println(fmt.Sprintf("%s status: %s", desResp.Name, desResp.Status)) // GetExecutionHistory _, err = GetExecutionHistory(fnfCli) if err != nil { panic(err) } }
回答
实现 Talk is cheap. Show me the code.
任务的定义 任务要包含需要执行的函数、以及函数要传的参数, 因为参数类型、个数不确定, 这里使用可变参数和空接口的形式
type Task struct {
Handler func(v ...interface{})
Params []interface{}
}
任务池的定义 任务池的定义包括了池的容量 capacity、当前运行的 worker（goroutine）数量 runningWorkers、任务队列（channel）taskC、关闭任务池的 channel closeC 以及任务池的状态 state（运行中或已关闭, 用于安全关闭任务池）
type Pool struct {
capacity uint64
runningWorkers uint64
state int64
taskC chan *Task
closeC chan bool
}
任务池的构造函数:
var ErrInvalidPoolCap = errors.New("invalid pool cap")
const (
RUNNING = 1
STOPED = 0
)
func NewPool(capacity uint64) (*Pool, error) {
if capacity <= 0 {
return nil, ErrInvalidPoolCap
}
return &Pool{
capacity: capacity,
state: RUNNING,
// 初始化任务队列, 队列长度为容量
taskC: make(chan *Task, capacity),
closeC: make(chan bool),
}, nil
}
启动 worker
新建 run() 方法作为启动 worker 的方法:
func (p *Pool) run() {
p.runningWorkers++ // 运行中的任务加一
go func() {
defer func() {
p.runningWorkers-- // worker 结束, 运行中的任务减一
}()
for {
select { // 阻塞等待任务、结束信号到来
case task, ok := <-p.taskC: // 从 channel 中消费任务
if !ok { // 如果 channel 被关闭, 结束 worker 运行
return
}
// 执行任务
task.Handler(task.Params...)
case <-p.closeC: // 如果收到关闭信号, 结束 worker 运行
return
}
}
}()
}
上述代码中, runningWorkers 的加减直接使用了自增运算, 但是考虑到启动多个 worker 时, runningWorkers 就会有数据竞争, 所以我们使用 sync.atomic 包来保证 runningWorkers 的自增操作是原子的。
对 runningWorkers 的操作进行封装:
func (p *Pool) incRunning() { // runningWorkers + 1
atomic.AddUint64(&p.runningWorkers, 1)
}
func (p *Pool) decRunning() { // runningWorkers - 1
atomic.AddUint64(&p.runningWorkers, ^uint64(0))
}
func (p *Pool) GetRunningWorkers() uint64 {
return atomic.LoadUint64(&p.runningWorkers)
}
打铁乘热, 对于 capacity 的操作也考虑数据竞争, 封装 GetCap() 方法:
func (p *Pool) GetCap() uint64 {
return atomic.LoadUint64(&p.capacity)
}
run() 方法改造:
func (p *Pool) run() {
p.incRunning()
go func() {
defer func() {
p.decRunning()
}()
for {
select {
case task, ok := <-p.taskC:
if !ok {
return
}
task.Handler(task.Params...)
case <-p.closeC:
return
}
}
}()
}
生产任务 新建 Put() 方法用来将任务放入池中:
func (p *Pool) Put(task *Task) {
if p.GetRunningWorkers() < p.GetCap() { // 如果任务池满, 则不再创建 worker
// 创建启动一个 worker
p.run()
}
// 将任务推入队列, 等待消费
p.taskC <- task
}
任务池安全关闭 当有关闭任务池来节省 goroutine 资源的场景时, 我们需要有一个关闭任务池的方法。
直接销毁 worker 关闭 channel 并不合适, 因为此时可能还有任务在队列中没有被消费掉。要确保所有任务被安全消费后再销毁掉 worker。
首先, 在关闭任务池时, 需要先关闭掉生产任务的入口。改造 Put() 方法:
var ErrPoolAlreadyClosed = errors.New("pool already closed")
func (p *Pool) Put(task *Task) error {
if p.state == STOPED { // 如果任务池处于关闭状态, 再 put 任务会返回 ErrPoolAlreadyClosed 错误
return ErrPoolAlreadyClosed
}
if p.GetRunningWorkers() < p.GetCap() {
p.run()
}
p.taskC <- task
return nil
}
在 run() 方法中已经对 closeC 进行了监听, 销毁 worker 只需等待任务被消费完后向 closeC 发出信号。Close() 方法如下:
func (p *Pool) Close() {
p.state = STOPED // 设置 state 为已停止
for len(p.taskC) > 0 { // 阻塞等待所有任务被 worker 消费
}
p.closeC <- true // 发送销毁 worker 信号
close(p.taskC) // 关闭任务队列
}
panic handler
每个 worker 都是一个 goroutine, 如果 goroutine 中产生了 panic, 会导致整个程序崩溃。为了保证程序的安全进行, 任务池需要对每个 worker 中的 panic 进行 recover 操作, 并提供可订制的 panic handler。
更新任务池定义:
type Pool struct {
capacity uint64
runningWorkers uint64
state int64
taskC chan *Task
closeC chan bool
PanicHandler func(interface{})
}
更新 run() 方法:
func (p *Pool) run() {
p.incRunning()
go func() {
defer func() {
p.decRunning()
if r := recover(); r != nil { // 恢复 panic
if p.PanicHandler != nil { // 如果设置了 PanicHandler, 调用
p.PanicHandler(r)
} else { // 默认处理
log.Printf("Worker panic: %s\n", r)
}
}
}()
for {
select {
case task, ok := <-p.taskC:
if !ok {
return
}
task.Handler(task.Params...)
case <-p.closeC:
return
}
}
}()
}
使用 OK, 我们的任务池就这么简单的写好了, 试试:
func main() {
// 创建任务池
pool, err := NewPool(10)
if err != nil {
panic(err)
}
for i := 0; i < 20; i++ {
// 任务放入池中
pool.Put(&Task{
Handler: func(v ...interface{}) {
fmt.Println(v)
},
Params: []interface{}{i},
})
}
time.Sleep(1e9) // 等待执行
}
详细例子见 mortar/examples
benchmark 作为协程池, 性能和内存占用的指标测试肯定是少不了的, 测试数据才是最有说服力的
测试流程 100w 次执行，原子增量操作
测试任务:
var wg = sync.WaitGroup{}
var sum int64
func demoTask(v ...interface{}) {
defer wg.Done()
for i := 0; i < 100; i++ {
atomic.AddInt64(∑, 1)
}
}
测试方法:
var runTimes = 1000000 // 原生 goroutine func BenchmarkGoroutineTimeLifeSetTimes(b *testing.B) {
for i := 0; i < runTimes; i++ {
wg.Add(1)
go demoTask2()
}
wg.Wait() // 等待执行完毕
}
// 使用协程池 func BenchmarkPoolTimeLifeSetTimes(b *testing.B) { pool, err := NewPool(20) if err != nil { b.Error(err) }
task := &Task{
Handler: demoTask2,
}
for i := 0; i < runTimes; i++ {
wg.Add(1)
pool.Put(task)
}
wg.Wait() // 等待执行完毕
} 对比结果
模式 操作时间消耗 ns/op 内存分配大小 B/op 内存分配次数 allocs/op 原生 goroutine (100w goroutine) 1596177880 103815552 240022 任务池开启 20 个 worker 20 goroutine) 1378909099 15312 89 使用任务池和原生 goroutine 性能相近（略好于原生）
使用任务池比直接 goroutine 内存分配节省 7000 倍左右, 内存分配次数减少 2700 倍左右
tips: 当任务为耗时任务时, 防止任务堆积（消费不过来）可以结合业务调整容量, 或根据业务控制每个任务的超时时间
回答
代码参考：
package main
import (
"net/url"
)
func main() {
urlstr := `{"userName":"huloixia","userPass":"030719"}`
println(urlstr, "\n")
//转码
encodeurl := url.QueryEscape(urlstr)
println(encodeurl, "\n")
//解码
decodeurl, err := url.QueryUnescape(encodeurl)
if err != nil {
panic(err)
}
println(decodeurl, "\n")
}
回答
你可以简单地制造struct并获得yaml。
我用于"github.com/ghodss/yaml"struct marshaling。请在导入中包含此内容。
Deployments, err := clientset.AppsV1().Deployments().List(metav1.ListOptions{})//and then loop through each deployment:for _, deploy := range Deployments.Items{
y, err := yaml.Marshal(deploy)
if err != nil {
panic(err)
}
fmt.Println("deployment print in yaml: ", string(y))
}