今天去面试阳光出行的经历记录一下

前几天接到阳光出行 golang开发岗面试邀请。预约的今天下午3点去面试。
工作环境也没看准网上写的那么差,整体还不错。

过程

下午面试分为两个环节
第一个人:
 先自我介绍,然后项目经验,技术问答。
第二个人:
 先自我介绍,然后项目经验,技术问答。

结果

 等二面通知,不知是不是会石沉大海。感觉没戏

总结

 当时有几个问题可能由于比较紧张。没回答上来,一会代码实现一下。
 该公司技术实力OK,工作氛围OK,面试我的人技术很不错。

由于紧张没回答出来的技术问题

问题:

比较关键的一个问题是goroutine协程池的设计,还有多线程单例模式的问题
多线程单例模式其实就是线程安全问题吧,多线程单例问题点击查看

以下是简单实现一个协程一个任务投递

package main
import (
 "fmt"
 "time"
)
func main() {
 task :=make(chan func())
 //单个协程
 go func(in chan func()) {
 for{
 fmt.Println("等待任务处理")
 f := <-in
 f()
 }
 }(task)
 //投递100个任务
 for i:=0; i<100; i++ {
 task <- func(i int) func() {
 return func() {
 fmt.Println(i)
 }
 }(i)
 }
 time.Sleep(10 * time.Second)
}

思路:

将一个任务投递到管道, 协程消费管道。

但以上代码,无论是控制,扩展都很难实现

升级版

以下代码为 协程池的实现

package main
import (
 "fmt"
 "log"
 "math/rand"
 "time"
)
//任务类型定义
type TaskFunc func(int)
//简单的协程池
type CoPool struct {
 //协程数量
 PoolNum int
 //如果有10个协程,那么与之对应的就要有10个chan
 taskChans []chan TaskFunc
 //均衡投递
 offset int
}
//获取协程池对象
func NewCoPool(poolNum int) *CoPool {
 cp := &CoPool{PoolNum: poolNum}
 cp.init()
 return cp
}
//初始化协程池
func (this *CoPool) init() {
 //创建 N个管道
 this.taskChans = make([]chan TaskFunc, this.PoolNum)
 //创建 N个协程
 for i := 0; i < this.PoolNum; i++ {
 this.taskChans[i] = make(chan TaskFunc)
 go func(id int, taskChan chan TaskFunc) {
 for {
 log.Printf("[协程:%d] 等待处理任务\n", id)
 task := <-taskChan
 task(id)
 }
 }(i, this.taskChans[i])
 }
 //offset
 this.offset = 0
 log.Println("初始化 协程池")
}
//投递任务
func (this *CoPool) pushTask(taskFunc TaskFunc) {
 //taskIndex := this.offset%this.PoolNum
 taskChan := this.taskChans[this.offset%this.PoolNum]
 taskChan <- taskFunc
 this.offset++
}
func main() {
 pool := NewCoPool(10)
 for i := 0; i < 100; i++ {
 fmt.Printf("投递任务[%d]\n", i)
 pool.pushTask(func(i int) func(id int) {
 return func(id int) {
 r:=rand.New(rand.NewSource(time.Now().UnixNano()))
 log.Printf("协程[%d]执行任务[%d]\n", id, i)
 time.Sleep(time.Millisecond * time.Duration(r.Intn(500)))
 }
 }(i))
 }
 time.Sleep(time.Second * 100)
}

看似差不多完成了, 但事实上经不起推敲,这里用轮询方式向协程投递任务。但投递的任务执行时间无法预计。比如有只有两个协程,有三个任务,执行时间分别为 1s, 5ms,1s。那么协程1就有2个1秒的任务在执行,而协程2只有一个 5ms的任务,相当于 协程1的第二个任务需要等前面一个任务执行完,才能执行第二个,而协程1在执行第二个任务的时候协程2确实空的。所以还有很大的优化空间。

思路

如果想知道某协程内是否执行完某任务,我能想到的就是用channel

以下是代码实现:

package main
import (
 "fmt"
 "log"
 "math/rand"
 "time"
)
//任务类型定义
type TaskFunc func(int)
//简单的协程池
type CoPool struct {
 //协程数量
 PoolNum int
 //如果有10个协程,那么与之对应的就要有10个chan
 taskChans []chan TaskFunc
 //均衡投递 X
 //offset int
 //freePool
 freePool chan int
}
//获取协程池对象
func NewCoPool(poolNum int) *CoPool {
 cp := &CoPool{PoolNum: poolNum}
 cp.init()
 return cp
}
func (this *CoPool) init() {
 //创建 N个管道
 this.taskChans = make([]chan TaskFunc, this.PoolNum)
 this.freePool = make(chan int,this.PoolNum)
 //创建 N个协程
 for i := 0; i < this.PoolNum; i++ {
 this.freePool <- i
 this.taskChans[i] = make(chan TaskFunc)
 go func(id int, taskChan chan TaskFunc, finish chan int) {
 for {
 log.Printf("[协程:%d] 等待处理任务\n", id)
 task := <-taskChan
 task(id)
 this.freePool <- id
 }
 }(i, this.taskChans[i], this.freePool)
 }
 //offset 优化掉
 //this.offset = 0
 log.Println("初始化 协程池")
}
//投递任务
func (this *CoPool) pushTask(taskFunc TaskFunc) {
 //taskIndex := this.offset%this.PoolNum
 //taskChan := this.taskChans[this.offset%this.PoolNum]
 //taskChan <- taskFunc
 //this.offset++
 taskChan := this.taskChans[<-this.freePool]
 taskChan <- taskFunc
}
func main() {
 pool := NewCoPool(10)
 for i := 0; i < 1000; i++ {
 fmt.Printf("投递任务[%d]\n", i)
 pool.pushTask(func(i int) func(id int) {
 return func(id int) {
 r := rand.New(rand.NewSource(time.Now().UnixNano()))
 log.Printf("协程[%d]执行任务[%d]\n", id, i)
 time.Sleep(time.Millisecond * time.Duration(r.Intn(500)))
 }
 }(i))
 }
 time.Sleep(time.Second * 100)
}

当然这样貌似成功了,但是还有很多问题,例如某个投递的任务卡死了,一直阻塞某一个 协程,如果这样的任务把所有的协程阻塞了,那样是不可靠的,还有自动扩容机制,比如默认开启10个协程,但犹豫投递任务执行时间很长,阻塞了10个协程,这样是不好的,所以有一个 最大协程数比较好。不过今天有点晚了, 明天再实现吧

只是记录一下,勿喷,希望大佬们能多提意见

有疑问加站长微信联系(非本文作者)

• 请尽量让自己的回复能够对别人有帮助
• 支持 Markdown 格式, **粗体**、~~删除线~~、`单行代码`
• 支持 @ 本站用户;支持表情(输入 : 提示),见 Emoji cheat sheet
• 图片支持拖拽、截图粘贴等方式上传