- 论坛徽章:
- 36
|
回复 24# yulihua49
golang协程的栈,好像是不够用的时候语言底层自动扩展,也不需要自己操心
事件,怎么说呢,比如lua里我有这样写:- local eventCenter = {}
- eventCenter.events = {}
- function eventCenter:new(name, event, cb)
- if self.events[name] then
- assert(false, "eventCenter", "eventCenter:new Error: eventCenter addListener, listener already exists!")
- return
- end
- print("eventCenter:new: ", name, event, cb)
- self.events[name] = {event=event, cb=cb}
- end
- function eventCenter:delete(name)
- self.events[name] = nil
- end
- function eventCenter:dispatch(event, ...)
- print("eventCenter dispatch: ", event, ...)
- for _, v in pairs(self.events) do
- if event == v.event then
- print("eventCenter dispatch222: ", event, ...)
- v.cb(event, ...)
- end
- end
- end
- return eventCenter
复制代码 因为lua单线程的,不需要锁,其他语言比如golang,new、delete、dispatch的时候上锁就好了
也就算个观察者模式或者发布-订阅吧
跨进程,就用socket,几个new、delete、dispatch,几个消息号和key data就是了
golang进程内的我也写了个,不过是刚接触golang的时候写的,写完没整理代码
- import (
- //"fmt"
- "sync"
- )
- type EventMgr struct {
- listenerMap map[interface{}]interface{}
- listeners map[interface{}]map[interface{}]EventHandler
- mutex *sync.Mutex
- valid bool
- }
- var (
- defaultInstance *EventMgr = nil
- instanceMap map[interface{}]*EventMgr
- instanceMutex = &sync.Mutex{}
- )
- func eventHandler(handler EventHandler, event interface{}, args []interface{}) {
- defer PanicHandle(true)
- handler(event, args)
- }
- func (eventMgr *EventMgr) NewListener(tag interface{}, event interface{}, handler EventHandler) bool {
- eventMgr.mutex.Lock()
- defer eventMgr.mutex.Unlock()
- if _, ok := eventMgr.listenerMap[tag]; ok {
- LogError(LOG_IDX, LOG_IDX, "NewListener Error: listener %v exist!", tag)
- return false
- }
- eventMgr.listenerMap[tag] = event
- if eventMgr.listeners[event] == nil {
- eventMgr.listeners[event] = make(map[interface{}]EventHandler)
- }
- eventMgr.listeners[event][tag] = handler
- return true
- }
- func (eventMgr *EventMgr) DeleteListener(tag interface{}) {
- eventMgr.mutex.Lock()
- defer eventMgr.mutex.Unlock()
- if event, ok := eventMgr.listenerMap[tag]; ok {
- delete(eventMgr.listenerMap, tag)
- delete(eventMgr.listeners[event], tag)
- }
- }
- func (eventMgr *EventMgr) Dispatch(event interface{}, args ...interface{}) {
- eventMgr.mutex.Lock()
- defer eventMgr.mutex.Unlock()
- if listeners, ok := eventMgr.listeners[event]; ok {
- for _, listener := range listeners {
- eventHandler(listener, event, args)
- }
- }
- }
- func GetInstance() *EventMgr {
- if defaultInstance == nil {
- defaultInstance = &EventMgr{
- listenerMap: make(map[interface{}]interface{}),
- listeners: make(map[interface{}]map[interface{}]EventHandler),
- mutex: &sync.Mutex{},
- valid: true,
- }
- }
- return defaultInstance
- }
- func NewEventMgr(tag interface{}) *EventMgr {
- instanceMutex.Lock()
- defer instanceMutex.Unlock()
- if _, ok := instanceMap[tag]; ok {
- LogError(LOG_IDX, LOG_IDX, "NewEventMgr Error: EventMgr %v exist!", tag)
- return nil
- }
- eventMgr := &EventMgr{
- listenerMap: make(map[interface{}]interface{}),
- listeners: make(map[interface{}]map[interface{}]EventHandler),
- mutex: &sync.Mutex{},
- valid: true,
- }
- if instanceMap == nil {
- instanceMap = make(map[interface{}]*EventMgr)
- }
- instanceMap[tag] = eventMgr
- return eventMgr
- }
- func DeleteEventMgr(tag interface{}) {
- instanceMutex.Lock()
- defer instanceMutex.Unlock()
- if eventMgr, ok := instanceMap[tag]; ok {
- eventMgr.mutex.Lock()
- defer eventMgr.mutex.Unlock()
- for k, e := range eventMgr.listenerMap {
- if emap, ok := eventMgr.listeners[e]; ok {
- for kk, _ := range emap {
- delete(emap, kk)
- }
- }
- delete(eventMgr.listeners, k)
- }
- delete(instanceMap, tag)
- }
- }
- func GetEventMgrByTag(tag interface{}) (*EventMgr, bool) {
- instanceMutex.Lock()
- defer instanceMutex.Unlock()
- if eventMgr, ok := instanceMap[tag]; ok {
- return eventMgr, true
- }
- return nil, false
- }
复制代码 |
|