#### 两个例子 1.GUI event loop ``` while (running) { // 从事件队列里获取一个事件 Event event = getNextEvent(); // Handle event... } ``` 2.Central event bus 不同系统公用的通信中心 #### 有问题的code ``` class Audio { public: static void playSound(SoundId id, int volume); }; class Audio { public: static void playSound(SoundId id, int volume); }; class Menu { public: void onSelect(int index) { Audio::playSound(SOUND_BLOOP, VOL_MAX); // Other stuff... } }; ``` 问题: 1. api同步调用, 阻塞到audio处理完请求 2. 多个请求不能合并处理 3. 处理请求有可能运行在错误的线程上(没有锁) ####模式定义: ``` 一系列的通知或请求存储在先进先出的队列里. 发送通知进行入队; 请求处理者从队列里获取请求. ``` ##### 何时使用 ``` 1.如果只是想从sender那里获取消息,使用 observer 或者command将会更简单. 2.当你需要push什么到另一个模块,或者pull什么从另一个地方的时候, 你需要一个buffer, 此时就需要一个队列了. 3. 队里提供的pull操作, receiver可以延迟处理,合并请求, 或者丢弃. pull请求不开放给sender使用,当sender需要获得响应的时候,队列就有点技穷了.(send then pray) ``` #### 注意事项 ``` 1.中心事件队列是个全局变量 2.世界状态会改变,(队列处理不是及时的) 3.困在反馈循环里(a ->b -> a ->b ...).如果是同步队列的,你会很快的发现循环bug. 一般原则: 避免在在处理事件的函数里发送事件. ``` #### Sample Code ``` struct PlayMessage { SoundId id; int volume; }; class Audio { public: static void init() { numPending_ = 0; } // Other stuff... private: static const int MAX_PENDING = 16; static PlayMessage pending_[MAX_PENDING]; static int numPending_; }; void Audio::playSound(SoundId id, int volume) { assert(numPending_ < MAX_PENDING); pending_[numPending_].id = id; pending_[numPending_].volume = volume; numPending_++; } class Audio { public: static void update() { for (int i = 0; i < numPending_; i++) { ResourceId resource = loadSound(pending_[i].id); int channel = findOpenChannel(); if (channel == -1) return; startSound(resource, channel, pending_[i].volume); } numPending_ = 0; } // Other stuff... }; ``` ##### ring buffer 循环buffer ``` class Audio { public: static void init() { head_ = 0; tail_ = 0; } // Methods... private: static int head_; static int tail_; // Array... }; void Audio::playSound(SoundId id, int volume) { assert((tail_ + 1) % MAX_PENDING != head_); // Add to the end of the list. pending_[tail_].id = id; pending_[tail_].volume = volume; tail_ = (tail_ + 1) % MAX_PENDING; } void Audio::update() { // If there are no pending requests, do nothing. if (head_ == tail_) return; ResourceId resource = loadSound(pending_[head_].id); int channel = findOpenChannel(); if (channel == -1) return; startSound(resource, channel, pending_[head_].volume); head_ = (head_ + 1) % MAX_PENDING; } ``` ##### 合并请求 ``` void Audio::playSound(SoundId id, int volume) { // Walk the pending requests. for (int i = head_; i != tail_; i = (i + 1) % MAX_PENDING) { if (pending_[i].id == id) { // Use the larger of the two volumes. pending_[i].volume = max(volume, pending_[i].volume); // Don't need to enqueue. return; } } // Previous code... } ``` ##### 多线程 push pull操作需要线程安全 #### 队列里保存的是什么 ``` event or message 1 event queue(一对多) 描述一些已经发生的事情, 类似异步的observer模式 1.允许多个监听者, 队列里保存的都是*已经发生的事件*, 发送者不关心谁去接受它. 2.作用域更广.被用于广播一类的事情.趋向于全局可见. 2 message queue(多对一) 更趋向于只有一个监听者. 多个请求从不同的地方发来,一个处理者进行处理 ``` #### 谁可以读队列 ``` 1 单播队列: 1.队列实现读取. 发送者只管发送 2.队列被封装的更好 3.没有读取竞争(决定是广播还是挨个分配) 2 广播队列: 1.如果没有监听者,event被丢弃 2.你可能会需要一个事件过滤 3 工作队列: 类似广播队列,比如worker pool 1.需要调度 ``` #### 谁可以写队列 ``` 1 一个写者(类似同步observer) 1.你明确知道事件是谁发出的 2.通常允许多个读者 2 多个写者 1.注意循环 2.需要有访问发送者的途径(事件里包含sender的引用) ``` #### 队里里对象的生命周期 ``` 1. 转移所有权. 有发送者转给队列,队列转给接受者 2. 共享所有权. 3. 所有权只给队列. (队列申请内存,然后发送者填充数据, 接受者得到引用) ``` ###See also ``` 1. 队列很像是异步的observer 2. message queue, pub sub 3. 有限状态机, 状态机需要输入,如果你想异步执行,可以使用队列. 如果你需要多个状态机互相发消息, 需要一个queue接受输入(mail box), 这叫做actor model 4. go语言内置的channel本质上就是个 事件或消息 队列. ```