阅读开源作品，是快速提升自身水平的最好方式之一。好的开源作品浓缩了高手的智慧和高超的编程技巧和思想，长期阅读会让这些珍贵的经验和技巧不知不觉回馈到我们的日常工作中。所以，阅读开源作品是必须掌握的一项技能。本人会在此篇开始逐渐记录阅读的点点滴滴，分享给读者朋友，和我一起进步！

GOIM简介

goim是bilibili公司技术总监毛剑创作，用于B站生产线上的IM服务框架，其框架原理图如下，有兴趣的同学可以转到官网查看介绍，由于侧重点原因，这里暂不多做介绍。

解读思路

我会用庖丁解牛的方式解读，而非自上而下的方式。

自上而下的优点是：呈框架体系的方式进行阅读。缺点也很明显：会在前期灌输大量的概念和设计，比如Bucket、Comet、Proto等。这样就会在一开始就打击阅读者的积极性。

所以采用了细化分层的方式解读，关注每一个部位细节，偶有其他模块的扩展，最后再把所有的模块串联起来，达到"解读之后，未尝见全牛也"的程度。

代码解读(Bucket)

注:此处的代码是我手动敲上去的，记录了自己的思维，也为了加深理解和方便解读。由于版本原因，建议读者朋友转到github拉取源码对照解读。（csdn的markdown暂不支持golang语法高亮，请谅解）

package main
import(
	"goim/libs/define"
	"goim/libs/proto" //libs包含了对bufio,bytes,net等原生包的改写，
		 	  		  //个人觉得还是很考验阅读能力的
	"sync"
	"sync/atomic"
)

type BucketOptions struct { //Bucket操作
	ChannelSize 		int		
	RoomSize 			int		
	RoutineAmount 		uint64	//Size和Amount这些貌似是固定大小的
}

type Bucket struct { 
	cLock 		sync.RWMutex		//确保chs的协程安全
	chs 		map[string]*Channel	//订阅字符为key，channel实体为value
	boptions 	BucketOptions		
	rooms 		map[int32]*Room
	routines 	[]chan *proto.BoardcaseRoomArg //用于广播给bucket下所有的room
	routinesNum uint64
}

//创建Bucket实体
func NewBucket(boptions BucketOptions) (b *Bucket){
  b = new(Bucket)
  b.chs = make(map[string]*Channel, boptions.ChannelSize)
  b.boptions = boptions
  
  //room
  b.rooms = make(map[int32]*Room, boptions.RoomSize)
  //为广播房间数创建对应数量的gorounite?
  b.routines = make([]chan *proto.BoardcastRoomArg, boptions.RoutineAmount)
  for i:= uint64(0); i < boptions.RoutineAmount; i++ {
    c := make(chan *proto.BoardcastRoomArg, boptions.RoutineSize)
    b.routines[i] = c
    go b.roomproc(c)
  }
  return 
}

//bucket中Channel个数
func (b *Bucket) ChannelCount() int {
  return len(b.chs)
}

//bucket中Room个数
func (b *Bucket) RoomCount() int {
  return len(b.rooms)
}

//sub key为key，ch为channel，rid是Room号，一并初始化并put到Bucket中
func (b *Bucket) Put(key string, rid int32, ch *Channel) (err error){
  var (
  	room *Room
    ok bool
  )
  //map非线程安全，故加锁保护
  b.cLock.Lock()
  b.chs[key] = ch
  if rid != define.NoRoom { //define.NoRoom = -1，意思是没有房间信息
    if room, ok = b.rooms[rid]; !ok { 
      room = NewRoom(rid)
      b.rooms[rid] = room
    }
    ch.Room = room
  }
  b.cLock.Unlock()
  if room != nil {
    err = room.Put(ch)
  }
  return
}

//删除channel和room
//思考，channel和room有什么样的关系
//猜想，一个channel只对应唯一room,一个room有多个channel
func (b *Bucket) Del(key string) {
  var (
  	ok 		bool
    ch 		*Channel
    room 	*Room
  )
  //
  b.cLock.Lock()
  if ch, ok = b.chs[key]; ok {
    room = ch.Room
    delete(b.chs, key)
  }
  b.cLock.Unlock()
  if room != nil && room.Del(ch){
    //空room必须从bucket中删除
    b.DelRoom(room)
  }
}

//Channel get a channel by sub key
func (b *Bucket) Channel(key string) (ch *Channel) {
  b.cLock.RLock()//Lock用于读写不确定的情况下，有强制性
  				//RLock用于读多写少的情况，这就是使用RLock的原因
  				//也可理解互斥锁和读写锁的区别
  				//课后作业，到底底层区别在哪
  ch = b.chs[key]
  b.cLock.RUnlock()
  return
}

//广播消息给Bucket下所有的channels
//由此可见，Proto是消息单位体
func (b *Bucket) Broadcast(p *proto.Proto) {
  var ch *Channel
  b.cLock.RLock()
  for _, ch = range b.chs {
    ch.Puch(p)
  }
  b.cLock.RUnlock()
}

//get a room by rid
func (b *Bucket) Room(rid int32) (room *Room) {
  b.cLock.RLock()
  room, _ = b.rooms[rid]
  b.cLock.RUnlock()
  return
}

//delete a room of bucket by room pointer
func (b *Bucket) DelRoom(room *Room) {
  b.cLock.Lock()
  delete(b.rooms, room.Id)
  b.cLock.Unlock()
  room.Close()
  return
}

//向Bucket下所有Room广播信息
func (b *Bucket) BroadcastRoom(arg *proto.BoardcastRoomArg) {
  //原子增加，最终的数量不超过RountineAmount
  //课后作业，原子操作和加锁保护的区别在哪？
  num := atomic.AddUint64(&b.routinesNum, 1) % b.boptions.RoutineAmount
  b.routines[num] <- arg
}

//获取在线数据大于1(Online > 1)的所有room
func (b *Bucket) Rooms() (res map[int32]struct{}) {
  var (
  	roomId 	int32
    room 	*Room
  )
  res = make(map[int32]struct{})
  b.cLock.RLock()
  for roomId, room = range b.rooms {
    if room.Online > 0 {
      res[roomId] = struct{}{}
    }
  }
  b.cLock.RUnlock()
  return
}

func (b *Bucket) roomproc(c chan *proto.BoardcastRoomArg) {
  for {
    var (
    	arg 	*proto.BoardcastRoomArg
      	room 	*Room
    )
    arg = <- c
    if room = b.Room(arg.RoomId); room != nil {
      room.Push(&arg.P)
    }
  }
}

图解

由图中可以看出。Bucket管理者Rooms和Channel，都是以map数据结构保存，room是以rid(roomId)为key，room实体指针为value，Channel是subkey为key，channel实体指针为value。

一个channel维护着一个长链接用户，对应着唯一的room，而同一个room拥有多条channel, 后续解读这条论证。

Bucket提供了常用的del，put以及广播给旗下的channel或room消息等接口，比较好理解。

这里需要注意下roomproc接口

在创建一个Bucket(NewBucket()) 之后，分配一个大小为boptions.RoutineSize的BoardcastRoomArg，共RoutineAmount个gorountine，每一个gorountine维护一个roomproc接口，一直阻塞监听，只要有BoardcastRoomArg塞入，即自动广播给room。

课后作业

源码中经常出现RUnlock和RLock读写锁，读写锁和互斥锁用途的主要区别在哪？分别适应什么样的场景？底层源码实现又是有怎样的区别？

这是我的提升点之一，也欢迎读者朋友们一起探索回答，下一篇将首先解读课后作业，后期见。