Golang面试题目-并发题目（选择题）

1、阅读下例代码，从以下四个选项中选择代码执行结果（Mutex相关）。

package main​import (  "fmt"  "sync")​var mu sync.Mutexvar chain string​func main() {  chain = "main"  A()  fmt.Println(chain)}​func A() {  mu.Lock()  defer mu.Unlock()  chain = chain + " --> A"  B()}​func B() {  chain = chain + " --> B"  C()}​func C() {  mu.Lock()  defer mu.Unlock()  chain = chain + " --> C"}

选项如下：

1. 不能编译

2. 输出main-->A-->B-->C

3. 输出main

4. panic

解析：4。上述代码会产生死锁panic，因为Mutex是互斥锁。

2、阅读下例代码，从以下四个选项中选择代码执行结果（RWMutex相关）。

package main​import (  "fmt"  "sync"  "time")​var mu sync.RWMutexvar count int​func main() {  go A()  time.Sleep(2 * time.Second)  mu.Lock()  defer mu.Unlock()  count++  fmt.Println(count)}​func A() {  mu.RLock()  defer mu.RUnlock()  B()}​func B() {  time.Sleep(5 * time.Second)  C()}​func C() {  mu.RLock()  defer mu.RUnlock()}

选项如下：

1. 不能编译

2. 输出 1

3. 程序hang住

4. panic

解析：4。上述代码会产生死锁panic，根据sync/rwmutex.go中的注释可以知道，读写锁当有一个协程在等待写锁时，其它协程是不能获得读锁，而在A和C中同一个调用链中间需要让出读锁，让写锁优先获取，而A的读锁又要求C调用完成，因此产生死锁。

3、阅读下例代码，从以下四个选项中选择代码执行结果（WaitGroup相关）。

package main​import (  "sync"  "time")​func main() {  var wg sync.WaitGroup  wg.Add(1)  go func() {    time.Sleep(time.Millisecond)    wg.Done()    wg.Add(1)  }()​  wg.Wait()}

选项如下：

1. 不能编译

2. 无输出，正常退出

3. 程序hang住

4. panic

解析：4。WaitGroup在调用Wait之后是不能再调用Add方法的。

4、阅读下例代码，从以下四个选项中选择代码执行结果（双检查实现单例）。

package main​import "sync"​type Once struct {  m    sync.Mutex  done uint32}​func (o *Once) Do(f func()) {  if o.done == 1 {    return  }​  o.m.Lock()  defer o.m.Unlock()​  if o.done == 0 {    o.done = 1    f()  }}

选项如下：

1. 不能编译

2. 可以编译，正确实现了单例

3. 可以编译，有并发问题，f函数可能会被执行多次

4. 可以编译，但是运行程序会panic

解析：3。在多核CPU中，因为CPU缓存会导致多个核心中变量值不同步。

5、阅读下例代码，从以下四个选项中选择代码执行结果（Mutex相关）。

package main​import (  "fmt"  "sync")​type MyMutex struct {  count int  sync.Mutex}​func main() {  var mu MyMutex  mu.Lock()  var mu2 = mu  mu.count++  mu.Unlock()  mu2.Lock()  mu2.count++  mu2.Unlock()  fmt.Println(mu.count, mu2.count)}

选项如下：

1. 不能编译

2. 输出 1,1

3. 输出 1,2

4. panic

解析：4。加锁后复制变量，会将锁的状态也复制过来，所以mul其实是已经加锁的状态，再加锁会产生死锁。

6、阅读下例代码，从以下四个选项中选择代码执行结果（Pool相关）。

package main​import (  "bytes"  "fmt"  "runtime"  "sync"  "time")​var pool = sync.Pool{  New: func() interface{} {    return new(bytes.Buffer)  },}​func main() {  go func() {    for {      processRequest(1 << 28) // 256MiB    }  }()​  for i := 0; i < 1000; i++ {    go func() {      for {        processRequest(1 << 10) // 1KiB      }    }()  }​  var stats runtime.MemStats  for i := 0; ; i++ {    runtime.ReadMemStats(&stats)    fmt.Printf("Cycle %d: %dB\n", i, stats.Alloc)    time.Sleep(time.Second)    runtime.GC()  }}​func processRequest(size int) {  b := pool.Get().(*bytes.Buffer)  time.Sleep(500 * time.Millisecond)  b.Grow(size)  pool.Put(b)  time.Sleep(1 * time.Millisecond)}

选项如下：

1. 不能编译

2. 可以编译，运行时正常，内存稳定

3. 可以编译，运行时内存可能暴涨

4. 可以编译，运行时内存先暴涨，但是过一会儿会回收掉

解析：3。在单核CPU中内存可能会稳定在256MB，如果是多核CPU则会暴涨。

7、阅读下例代码，从以下四个选项中选择代码执行结果（channel相关）。

package main​import (  "fmt"  "runtime"  "time")​func main() {  var ch chan int  go func() {    ch = make(chan int, 1)    ch <- 1  }()​  go func(ch chan int) {    time.Sleep(time.Second)    <-ch  }(ch)​  c := time.Tick(1 * time.Second)  for range c {    fmt.Printf("#goroutines: %d\n", runtime.NumGoroutine())  }}

选项如下：

1. 不能编译

2. 一段时间后总是输出 #goroutine:1

3. 一段时间后总是输出 #goroutine:2

4. panic

解析：3。因ch未初始化，读写channel都会阻塞，之后被第一个协程重新赋值，导致写的ch都会阻塞。

8、阅读下例代码，从以下四个选项中选择代码执行结果（channel相关）。

package main​import (  "fmt")​func main() {  var ch chan int  var count int  go func() {    ch <- 1  }()​  go func() {    count++    close(ch)  }()​  <-ch  fmt.Println(count)}

选项如下：

1. 不能编译

2. 输出 1

3. 输出 0

4. panic

解析：4。ch未被初始化，关闭时会报错。

9、阅读下例代码，从以下四个选项中选择代码执行结果（Map相关）。

package main​import (  "fmt"  "sync")​func main() {  var m sync.Map  m.LoadOrStore("a", 1)  m.Delete("a")  fmt.Println(m.Len())}

选项如下：

1. 不能编译

2. 输出 1

3. 输出 0

4. panic

解析：1。sync.Map没有Len方法。

10、阅读下例代码，选择代码执行结果（happens before相关）。

package main​var c = make(chan int)var a int​func f() {  a = 1  <-c}​func main() {  go f()  c <- 0  print(a)}

选项如下：

1. 不能编译

2. 输出 1

3. 输出 0

4. panic

解析：2。c<-0会阻塞依赖与f()的执行。

扫码关注公众号，获取更多优质内容。