教程集 > Golang编程 > 正文 Golang经典面试题上

Golang经典面试题上

发布时间：2021-12-10 编辑：jiaochengji.com

教程集为您提供Golang经典面试题上等资源，欢迎您收藏本站，我们将为您提供最新的Golang经典面试题上资源

在这个案例中，<code>触发异常</code>这几个字打印的顺序其实是不确定的。<code>defer</code>, <code>panic</code>, <code>recover</code>一般都会配套使用来捕捉异常。先看下面的案例：

<ul><li>案例一</li></ul><pre class="prettyprint"><code class=" hljs go">package main import ( "fmt" ) func main() { defer_call() } func defer_call() { defer func() { fmt.Println("打印前") }() defer func() { fmt.Println("打印中") }() defer func() { // 必须要先声明defer，否则recover()不能捕获到panic异常 if err := recover();err != nil { fmt.Println(err) //err 就是panic传入的参数 } fmt.Println("打印后") }() panic("触发异常") }</code></pre>

输出内容为：

<pre class="prettyprint"><code class=" hljs vhdl">触发异常打印后打印中打印前 Process finished with exit code 0</code></pre> <ul><li>案例二</li></ul><pre class="prettyprint"><code class=" hljs go">package main import ( "fmt" ) func main() { defer_call() } func defer_call() { defer func() { fmt.Println("打印前") }() defer func() { // 必须要先声明defer，否则recover()不能捕获到panic异常 if err := recover();err != nil { fmt.Println(err) //err 就是panic传入的参数 } fmt.Println("打印中") }() defer func() { fmt.Println("打印后") }() panic("触发异常") }</code></pre>

输出内容为：

<pre class="prettyprint"><code class=" hljs vhdl">打印后触发异常打印中打印前 Process finished with exit code 0</code></pre> <ul><li>案例三</li></ul><pre class="prettyprint"><code class=" hljs go">package main import ( "fmt" ) func main() { defer_call() } func defer_call() { defer func() { if err := recover();err != nil { fmt.Println(err) //err 就是panic传入的参数 } fmt.Println("打印前") }() defer func() { // 必须要先声明defer，否则recover()不能捕获到panic异常 if err := recover();err != nil { fmt.Println(err) //err 就是panic传入的参数 } fmt.Println("打印中") }() defer func() { if err := recover();err != nil { fmt.Println(err) //err 就是panic传入的参数 } fmt.Println("打印后") }() panic("触发异常") }</code></pre>

输出内容为：

总结：

<ol><li><code>defer</code>函数属延迟执行，延迟到调用者函数执行 <code>return</code> 命令前被执行。多个<code>defer</code>之间按<code>LIFO</code>先进后出顺序执行。</li><li><code>Go</code>中可以抛出一个<code>panic</code>的异常，然后在<code>defer</code>中通过<code>recover</code>捕获这个异常，然后正常处理。</li><li>如果同时有多个<code>defer</code>，那么异常会被最近的<code>recover()</code>捕获并正常处理。</li></ol><h3 id="2-以下代码有什么问题说明原因">2. 以下代码有什么问题，说明原因</h3> <pre class="prettyprint"><code class="language-Go hljs go">package main import ( "fmt" ) type student struct { Name string Age int } func pase_student() map[string]*student { m := make(map[string]*student) stus := []student{ {Name: "zhou", Age: 24}, {Name: "li", Age: 23}, {Name: "wang", Age: 22}, } for _, stu := range stus { m[stu.Name] = &stu } return m } func main() { students := pase_student() for k, v := range students { fmt.Printf("key=%s,value=%v \n", k, v) } }</code></pre>

运行结果：

<pre class="prettyprint"><code class=" hljs livecodeserver">key=zhou,value=&{wang 22} key=li,value=&{wang 22} key=wang,value=&{wang 22} Process finished with exit code 0</code></pre>

修改一下代码：

将下面的代码：

<pre class="prettyprint"><code class=" hljs matlab">for _, stu := range stus { m[stu.Name] = &stu }</code></pre>

修改为：

<pre class="prettyprint"><code class=" hljs perl">for _, stu := range stus { fmt.Printf("%v\t%p\n",stu,&stu) m[stu.Name] = &stu }</code></pre>

运行结果为：

<pre class="prettyprint"><code class=" hljs mathematica">{shen 24} 0xc4200a4020 {li 23} 0xc4200a4020 {wang 22} 0xc4200a4020 key=shen,value=&{wang 22} key=li,value=&{wang 22} key=wang,value=&{wang 22} Process finished with exit code 0</code></pre>

通过上面的案例，我们不难发现<code>stu</code>变量的地址始终保持不变，每次遍历仅进行<code>struct</code>值拷贝，故<code>m[stu.Name]=&stu</code>实际上一直指向同一个地址，最终该地址的值为遍历的最后一个<code>struct</code>的值拷贝。

形同如下代码：

<pre class="prettyprint"><code class=" hljs go">var stu student for _, stu = range stus { m[stu.Name] = &stu } </code></pre>

修正方案，取数组中原始值的地址：

<pre class="prettyprint"><code class=" hljs go">for i, _ := range stus { stu:=stus[i] m[stu.Name] = &stu }</code></pre>

重新运行，效果如下：

<pre class="prettyprint"><code class=" hljs mathematica">{shen 24} 0xc42000a060 {li 23} 0xc42000a0a0 {wang 22} 0xc42000a0e0 key=shen,value=&{shen 24} key=li,value=&{li 23} key=wang,value=&{wang 22} Process finished with exit code 0</code></pre> <h3 id="3-下面的代码会输出什么并说明原因">3. 下面的代码会输出什么，并说明原因</h3> <pre class="prettyprint"><code class=" hljs go">package main import ( "fmt" "runtime" "sync" ) func init() { fmt.Println("Current Go Version:", runtime.Version()) } func main() { runtime.GOMAXPROCS(1) count := 10 wg := sync.WaitGroup{} wg.Add(count * 2) for i := 0; i < count; i { go func() { fmt.Printf("[%d]", i) wg.Done() }() } for i := 0; i < count; i { go func(i int) { fmt.Printf("-%d-", i) wg.Done() }(i) } wg.Wait() }</code></pre>

运行效果：

<pre class="prettyprint"><code class=" hljs markdown">Current Go Version: go1.10.1 -9-[10][10][10][10][10][10][10][10][10][10]-0--1--2--3--4--5--6--7--8- Process finished with exit code 0</code></pre>

两个<code>for</code>循环内部<code>go func</code> 调用参数i的方式是不同的，导致结果完全不同。这也是新手容易遇到的坑。

第一个<code>go func</code>中<code>i</code>是外部<code>for</code>的一个变量，地址不变化。遍历完成后，最终<code>i=10</code>。故<code>go func</code>执行时，<code>i</code>的值始终是<code>10</code>（<code>10</code>次遍历很快完成）。

第二个<code>go func</code>中<code>i</code>是函数参数，与外部<code>for</code>中的<code>i</code>完全是两个变量。尾部(<code>i</code>)将发生值拷贝，<code>go func</code>内部指向值拷贝地址。

<h3 id="4-下面代码会输出什么">4. 下面代码会输出什么？</h3> <pre class="prettyprint"><code class=" hljs go">package main import "fmt" type People struct{} func (p *People) ShowA() { fmt.Println("showA") p.ShowB() } func (p *People) ShowB() { fmt.Println("showB") } type Teacher struct { People } func (t *Teacher) ShowB() { fmt.Println("teacher showB") } func main() { t := Teacher{} t.ShowA() }</code></pre>

运行结果如下：

<pre class="prettyprint"><code class=" hljs vhdl">showA showB Process finished with exit code 0</code></pre>

<code>Go</code>中没有继承,上面这种写法叫组合。

上面的<code>t.ShowA()</code>等价于<code>t.People.ShowA()</code>，将上面的代码修改如下：

<pre class="prettyprint"><code class=" hljs avrasm">func main() { t := Teacher{} t.ShowA() fmt.Println("---------------") t.People.ShowA() }</code></pre>

运行结果为：

<pre class="prettyprint"><code class=" hljs asciidoc">showA showB --------------- showA showB Process finished with exit code 0</code></pre> <h3 id="5-下面代码会触发异常吗请详细说明">5. 下面代码会触发异常吗？请详细说明</h3> <pre class="prettyprint"><code class=" hljs go">package main func main() { runtime.GOMAXPROCS(1) int_chan := make(chan int, 1) string_chan := make(chan string, 1) int_chan <- 1 string_chan <- "hello" select { case value := <-int_chan: fmt.Println(value) case value := <-string_chan: panic(value) } }</code></pre>

有可能会发生异常，如果没有<code>selct</code>这段代码，就会出现线程阻塞，当有<code>selct</code>这个语句后，系统会随机抽取一个<code>case</code>进行判断，只有有其中一条语句正常<code>return</code>，此程序将立即执行。

<h3 id="6-下面代码输出什么">6. 下面代码输出什么？</h3> <pre class="prettyprint"><code class=" hljs livecodeserver">package main import "fmt" func calc(index string, a, b int) int { ret := a b fmt.Println(index, a, b, ret) return ret } func main() { a := 1 b := 2 defer calc("1", a, calc("10", a, b)) a = 0 defer calc("2", a, calc("20", a, b)) b = 1 }</code></pre>

运行结果如下：

<pre class="prettyprint"><code class=" hljs vhdl">10 1 2 3 20 0 2 2 2 0 2 2 1 1 3 4 Process finished with exit code 0</code></pre>

在解题前需要明确两个概念：

<ul><li><code>defer</code>是在函数末尾的<code>return</code>前执行，先进后执行。</li><li>函数调用时 <code>int</code> 参数发生值拷贝。</li></ul>

不管代码顺序如何，<code>defer calc func</code>中参数<code>b</code>必须先计算，故会在运行到第三行时，执行<code>calc("10",a,b)</code>输出：<code>10 1 2 3</code>得到值<code>3</code>，将<code>cal("1",1,3)</code>存放到延后执执行函数队列中。

执行到第五行时，现行计算<code>calc("20", a, b)</code>即<code>calc("20", 0, 2)</code>输出：<code>20 0 2 2</code>得到值<code>2</code>,将<code>cal("2",0,2)</code>存放到延后执行函数队列中。

执行到末尾行，按队列先进后出原则依次执行：<code>cal("2",0,2)、cal("1",1,3)</code>，依次输出：<code>2 0 2 2、1 1 3 4</code> 。

<h3 id="7-请写出以下输入内容">7. 请写出以下输入内容</h3> <pre class="prettyprint"><code class=" hljs css">package main import "fmt" func main() { s := make([]int, 5) fmt.Printf("%p\n", s) s = append(s, 1, 2, 3) fmt.Printf("%p\n", s) //new pointer fmt.Println(s) }</code></pre>

运行结果:

<pre class="prettyprint"><code class=" hljs vhdl">0xc4200180c0 0xc42001c0a0 [0 0 0 0 0 1 2 3] Process finished with exit code 0</code></pre> <h3 id="8-下面的代码有什么问题">8. 下面的代码有什么问题</h3> <pre class="prettyprint"><code class=" hljs go"> package main import ( "fmt" "sync" ) type UserAges struct { ages map[string]int sync.Mutex } func (ua *UserAges) Add(name string, age int) { ua.Lock() defer ua.Unlock() ua.ages[name] = age } func (ua *UserAges) Get(name string) int { if age, ok := ua.ages[name]; ok { return age } return -1 } func main() { count := 1000 gw := sync.WaitGroup{} gw.Add(count * 3) u := UserAges{ages: map[string]int{}} add := func(i int) { u.Add(fmt.Sprintf("user_%d", i), i) gw.Done() } for i := 0; i < count; i { go add(i) go add(i) } for i := 0; i < count; i { go func(i int) { defer gw.Done() u.Get(fmt.Sprintf("user_%d", i)) }(i) } gw.Wait() fmt.Println("Done") }</code></pre>

输出结果：

<pre class="prettyprint"><code class=" hljs perl">fatal error: concurrent map read and map write goroutine 2022 [running]: runtime.throw(0x10c5472, 0x21)</code></pre>

结论： 在执行 <code>Get</code> 方法时可能被<code>panic</code>。

虽然有使用<code>sync.Mutex</code>做写锁，但是<code>map</code>是并发读写不安全的。<code>map</code>属于引用类型，并发读写时多个协程见是通过指针访问同一个地址，即访问共享变量，此时同时读写资源存在竞争关系。所以会报错误信息:<code>fatal error: concurrent map read and map write</code>。

如果第一次没复现<code>panic</code>问题，可以再次运行，复现该问题。那么如何改善呢? 在<code>Go1.9</code>新版本中将提供并发安全的<code>map</code>。首先需要了解两种锁的不同：

<ul><li><code>sync.Mutex</code>互斥锁</li><li><code>sync.RWMutex</code>读写锁，基于互斥锁的实现，可以加多个读锁或者一个写锁。</li></ul>

RWMutex相关方法：

<pre class="prettyprint"><code class=" hljs go">type RWMutex func (rw *RWMutex) Lock() func (rw *RWMutex) RLock() func (rw *RWMutex) RLocker() Locker func (rw *RWMutex) RUnlock() func (rw *RWMutex) Unlock()</code></pre>

代码改进如下：

<pre class="prettyprint"><code class=" hljs go">package main import ( "fmt" "sync" ) type UserAges struct { ages map[string]int sync.RWMutex } func (ua *UserAges) Add(name string, age int) { ua.Lock() defer ua.Unlock() ua.ages[name] = age } func (ua *UserAges) Get(name string) int { ua.RLock() defer ua.RUnlock() if age, ok := ua.ages[name]; ok { return age } return -1 } func main() { count := 10000 gw := sync.WaitGroup{} gw.Add(count * 3) u := UserAges{ages: map[string]int{}} add := func(i int) { u.Add(fmt.Sprintf("user_%d", i), i) gw.Done() } for i := 0; i < count; i { go add(i) go add(i) } for i := 0; i < count; i { go func(i int) { defer gw.Done() u.Get(fmt.Sprintf("user_%d", i)) fmt.Print(".") }(i) } gw.Wait() fmt.Println("Done") }</code></pre>

运行结果如下：

<pre class="prettyprint"><code class=" hljs asciidoc">. . . . Done Process finished with exit code 0</code></pre> <h3 id="9-下面的迭代会有什么问题">9. 下面的迭代会有什么问题？</h3> <pre class="prettyprint"><code class=" hljs go">package main import "fmt" import "sync" import "time" type ThreadSafeSet struct { sync.RWMutex s []int } func (set *ThreadSafeSet) Iter() <-chan interface{} { ch := make(chan interface{}) go func() { set.RLock() for elem := range set.s { ch <- elem fmt.Print("get:", elem, ",") } close(ch) set.RUnlock() }() return ch } func main() { //read() unRead() } func read() { set := ThreadSafeSet{} set.s = make([]int, 100) ch := set.Iter() closed := false for { select { case v, ok := <-ch: if ok { fmt.Print("read:", v, ",") } else { closed = true } } if closed { fmt.Print("closed") break } } fmt.Print("Done") } func unRead() { set := ThreadSafeSet{} set.s = make([]int, 100) ch := set.Iter() _ = ch time.Sleep(5 * time.Second) fmt.Print("Done") } </code></pre>

结论：内部迭代出现阻塞。默认初始化时无缓冲区，需要等待接收者读取后才能继续写入。

chan在使用make初始化时可附带一个可选参数来设置缓冲区。默认无缓冲，题目中便初始化的是无缓冲区的chan，这样只有写入的元素直到被读取后才能继续写入，不然就一直阻塞。

设置缓冲区大小后，写入数据时可连续写入到缓冲区中，直到缓冲区被占满。从chan中接收一次便可从缓冲区中释放一次。可以理解为chan是可以设置吞吐量的处理池。

<code>ch := make(chan interface{})</code>和 <code>ch := make(chan interface{},1)</code>是不一样的
无缓冲的不仅仅是只能向 <code>ch</code> 通道放一个值而是一直要有人接收，那么<code>ch <- elem</code>才会继续下去，要不然就一直阻塞着，也就是说有接收者才去放，没有接收者就阻塞。

而缓冲为<code>1</code>则即使没有接收者也不会阻塞，因为缓冲大小是<code>1</code>只有当放第二个值的时候第一个还没被人拿走，这时候才会阻塞

</blockquote> <h3 id="10-以下代码能编译过去吗为什么">10. 以下代码能编译过去吗？为什么？</h3> <pre class="prettyprint"><code class=" hljs go">package main import ( "fmt" ) type People interface { Speak(string) string } type Stduent struct{} func (stu *Stduent) Speak(think string) (talk string) { if think == "bitch" { talk = "You are a good boy" } else { talk = "hi" } return } func main() { var peo People = Stduent{} think := "bitch" fmt.Println(peo.Speak(think)) }</code></pre>

结论：编译失败，值类型 <code>Student{}</code> 未实现接口<code>People</code>的方法，不能定义为 <code>People</code> 类型。

两种正确修改方法：

<ul><li>方法一</li></ul><pre class="prettyprint"><code class=" hljs go">package main import ( "fmt" ) type People interface { Speak(string) string } type Stduent struct{} func (stu Stduent) Speak(think string) (talk string) { if think == "bitch" { talk = "You are a good boy" } else { talk = "hi" } return } func main() { var peo People = Stduent{} think := "hi" fmt.Println(peo.Speak(think)) }</code></pre> <ul><li>方法二</li></ul><pre class="prettyprint"><code class=" hljs go">package main import ( "fmt" ) type People interface { Speak(string) string } type Stduent struct{} func (stu Stduent) Speak(think string) (talk string) { if think == "bitch" { talk = "You are a good boy" } else { talk = "hi" } return } func main() { var peo People = &Stduent{} think := "bitch" fmt.Println(peo.Speak(think)) }</code></pre>

总结：指针类型的结构体对象可以同时调用结构体值类型和指针类型对应的方法。而值类型的结构体对象只能调用值类型对应的接口方法。

<blockquote class="layui-elem-quote" style="width: 100%;overflow:hidden"> 作者： qq_37133717
链接： https://blog.csdn.net/qq_37133717/article/details/80342287?ops_request_misc=%7B%22request%5Fid%22%3A%22161165207816780255245341%22%2C%22scm%22%3A%2220140713.130102334.pc%5Fblog.%22%7D&request_id=161165207816780255245341&biz_i
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
</blockquote>

到此这篇关于“Golang经典面试题上”的文章就介绍到这了,更多文章或继续浏览下面的相关文章，希望大家以后多多支持JQ教程网！

您可能感兴趣的文章：
想系统学习GO语言(Golang
:first-child和:last-child学习笔记
 go经典面试题:浅析接口
 golang map key 正则表达_在GoLang中实现线程安全的字典
 golang面试官：for select时，如果通道已经关闭会怎么样？如果select中只有一个case呢？
golang经典面试问题汇总
 Go开篇
 不要等离职了，才知道for select时，如果通道已经关闭会怎么样？
golang for循环_golang面试官：for select时，如果通道已经关闭会怎么样？如果select中只有一个case呢？...
golang面试经之笔试2

上一篇：go语言http服务处理image/css/js等静态文件下一篇：go语言加解密算法 md5 sha256

[关闭]

Golang经典面试题上

最近更新

浏览排行