如果只是判断是不是允许用户 user_a 访问数据表 table_a ，完全可以按照接口相同的方式来做

```go
package main

import "fmt"

// Greeting 定义为一个函数
type Greeting func(name string) string

func (g Greeting) say(n string) {
// g 调用函数自身
s := g(n)
fmt.Println(s)
}

func english(name string) string {
return "Hello, " + name
}

func main() {
// english 函数与 Greeting 签名相同，进行强转
greet := Greeting(english)
greet.say("World")

// 完整的长生命方法, 同时去除 english 的干扰项
var greet2 Greeting = func(s string) string {
return "Hello, " + s
}
fmt.Println(greet2("World!"))
greet2.say("World!")
}

```

```go
package main

import "fmt"

// Greeting 定义为一个函数
type Greeting func(name string) string

func (g Greeting) say(n string) {
// g 调用函数自身
s := g(n)
fmt.Println(s)
}

func english(name string) string {
return "Hello, " + name
}

func main() {
// english 函数与 Greeting 签名相同，进行强转
greet := Greeting(english)
greet.say("World")


var greet2 Greeting = func(s string) string {
return "Hello, " + s
}
fmt.Println(greet2("World!"))
greet2.say("World!")
}

```

像下面这样使用

```go
func left(ctx context.Context) {
ctx = right(ctx)
value := ctx.Value("key")
fmt.Println(value)
}

func right(ctx context.Context) context.Context {
return context.WithValue(ctx, "key", "value")
}
```

github 上找前几个实现，大多都对内存分配，key 、value 存储结构，锁的粒度做了优化

能重新再 debian 下编译打包吗

不折腾，用 float64

转岗或者换个研发工作，你会快速进步

钉钉之类的文字交流，更多是结果传递，你们就没经常遇到一两句，三五句文字越来越说不清楚，直接电话沟通的吗？

感觉现在的实现，如果是多个客户端，加锁时的 id 怎么分配的，冲突就展期，防止不了冲突，释放锁也是一样的

@hentailolicon 正常是这么做的，一般会在循环中加入检查 ctx.Done, 比如说在从流中读取数据，读取下一条数据等等，像 lysS 说的将任务实现为单一功能的小任务；

传递上下文，在需要的位置使用,比如在这里避免脏数据的话，向 chan 写数据之前的某个地方检查上下文是否超时或者已经 canceled
```go
select {
case <- ctx.Done():
default:
}

thinkbook14+或者 16+可以考虑一下

最后不这么用，context 传递的参数一般只用来做协程控制、超时控制，状态跟踪等，当然一层层的封装用相同的 key 传递 value ，下一步是能取到的

```go
package main

func main() {
chs := []chan struct{}{
make(chan struct{}), make(chan struct{}), make(chan struct{}),
}
next := make(chan struct{})
for i := 0; i < len(chs); i++ {
go func(i int) {
for range chs[i] {
b := byte('A' + i)
print(string(b))
if i != len(chs)-1 {
chs[i+1] <- struct{}{}
} else {
next <- struct{}{}

}
}
}(i)
}
for i := 0; i < 10; i++ {
chs[0] <- struct{}{}
<-next
}
}
```

i = i+1 不是原子操作,也没有锁,每个 goroutine 执行时随机的

遇到这种不讲道理的，写啥承诺，中间件加一个"X-Http-Method-Override",改成 POST

如果不用 Oauth2 做这件事，Java 中用的非常多的一个也没说需要同域

https://www.apereo.org/projects/cas

Go 中的方法函数实际上是个语法糖，在内部实现中，结构体或者指针就是它的第一个参数；至于一个方法要依赖另一个的问题，参考下 http 包中的 Request