1. 对map进行并发读写，下面方式安全的是（） ACD
    A.

type SafeMap struct {
    data map[interface{}]interface{}
    Lock sync.Mutex
}

func (s *SafeMap) Add(key interface{}, value interface{}) {
    s.Lock.Lock()
    defer s.Lock.UnLock()
    s.data[key] = value
}

 B.

type SafeMap struct {
    data map[interface{}]interface{}
}

func (s *SafeMap) Add(key interface{}, value interface{}) {
    s.data[key] = value
}

 C.

var m sync.Map
value, ok = m.LoadOrStore("Tom", 25)

 D.

type SafeMap struct {
    data map[interface{}]interface{}
    ch   chan func()
}

var SM *SafeMap
func NewSafeMap() *SafeMap {
    if SM == nil {
        s := &SafeMap{
            data: make(map[interface{}]interface{}),
            ch:   make(chan func()),
        }
        go func() {
            for {
                (<-s.ch)()
            }
        }()
        SM = s
        return SM
    }
    return SM
}

func (s *SafeMap) Add(key interface{}, value interface{}) {
    s.ch <- func() {
        s.data[key] = value
    }
}

2. 下面操作不会导致协程死锁（） F

 func main() {
    var c1 chan string = make(chan string， 1)
    go func() {
        c1 <- "1"
    }()
    time.Sleep(time.Second)
    c1 <- "1" //写操作阻塞
    fmt.Println("c1 is", <-c1)
    ...
}

3. 重复关闭channel会导致panic（） T
4. 打开一个文件，linux系统会返回一个文件句柄，如果没有关闭文件句柄的操作，会造成文件句柄泄露，下面存在泄漏风险的是（） AB
    A.

   file,err := os.Open("test.go")
   if err != nil {
       fmt.Println(err)
       return
   }

 B.

   response,err := http.Get("http://helloworld")
   if err != nil {
       fmt.Println(err)
       return
   }

 C.

   file,err := os.Open("test.go")
   if file != nil {
       defer file.Close()
   }
   if err != nil {
       fmt.Println(err)
       return
   }

 D.

   response,err := http.Get("http://helloworld")
   if response != nil {
       defer response.Body.Close()
   }
   if err != nil {
       fmt.Println(err)
       return
   }

5. 下面程序不会导致僵尸进程的出现（）F

   package main

   import (
       "log"
       "os/exec"
   )

   func main() {
       cmd := exec.Command("sleep", "5")
       err := cmd.Start()
       if err != nil {
           log.Fatal(err)
       }
   }

6. 开源beego框架[beego]，通过设置beego服务端接受访问请求中的__________（超过该阈值就将该请求抛弃）可达到防止DoS攻击的目的。 header大小
7. 下面程序不会出现CPU泄漏的问题（） T

   ch := make(chan int, 10)
   go func(){
       for{
           //ch被读取时可以有两个值，其中ok为bool类型值，true代表ch为正常channel，false代表ch被关闭。
           select {
               case val,ok := <- ch:
                if !ok {
                    log.Print("chan ch is closed")
                    return //退出协程
                }
                ... //处理val的代码
           }
       }  
   }()
   go func(){
        close(ch)
   }()

8. 向已关闭的channel发送数据会导致panic（） T
9. XSS攻击全称跨站脚本攻击，是一种在web应用中的计算机安全漏洞，它允许恶意web用户将代码植入到提供给其它用户使用的页面中，下面程序不存在XSS泄漏风险（）F

func (f *FileExportController) Post() {
    req := f.Ctx.Input.RequestBody
    param := &dto.ExportReq{}
    log.Debug("", "req strings", string(req))
    err := json.Unmarshal(req, &param)
    if err != nil {
        ...
        return
    }
    filePath, err := service.ProduceExportFile(param)
    if err != nil {
        //在错误处理时通过err.Error()函数将有问题的参数无意返回，导致web界面出现警报小框
        f.CustomAbort(http.StatusInternalServerError, err.Error())
    }
}

10. 直接运行SQL语句，存在SQL注入风险，可使用bind_param绑定方式或ORM方式来防止SQL注入攻击（）T

11-33：
选择：19、22、24、26、29-31、33-34（9道）
填空：7-12（6道）
判断：13-20（8道）