前几天接到阳光出行 golang开发岗面试邀请。预约的今天下午3点去面试。
整体还不错，工作环境也没看准网上写的那么差。
过程
下午面试分为两个环节
第一个人：
先自我介绍，然后项目经验，技术问答。
第二个人：
先自我介绍，然后项目经验，技术问答。
结果
等二面通知，不知是不是会石沉大海。感觉没戏
总结
当时有几个问题可能由于比较紧张。没回答上来，一会代码实现一下。
该公司技术实力OK，工作氛围OK，面试我的人技术很不错。人品也不错。
由于紧张没回答出来的技术问题
问题：
比较关键的一个问题是goroutine协程池的设计，还有多线程单例模式的问题
多线程单例模式其实就是线程安全问题吧，多线程单例问题点击查看
以下是简单实现协程池的过程，最简单的实现一个协程一个 channel
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)
}
思路：
image.png
将一个任务投递到管道， 协程消费管道。
但以上代码，无论是控制，扩展都很难实现
升级版
以下代码为 协程池的实现
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个协程，这样是不好的，所以有一个 最大协程数比较好。不过今天有点晚了， 明天再实现吧
只是记录一下，勿喷，希望大佬们能多提意见
