结合消息订阅发布模式，探讨了消息总线的大致方案。订阅发布模式可参考Publish/Subscribe。
其中尤其对订阅发布模式中的List-Based、Broadcast-Based、Content-Based三种方案进行了简单讲解。
参考此图。
文章提及了消息的识别与接受者匹配的方法，可参考BizTalk Server。

What's remote procedure call?
In an client/server system, an client could run an procedure on server machine by sending request and attendant parameters to server, and get the result returned from procedure operating result.

重写delete函数需要注意：
void operator delete(void *rawmemory, size_t size);
1> C++标准要求，允许rawmemory为空指针。
2> 子类继承时，delete子类时，基类中的operator delete传入的size参数可能和父类的sizeof不一致，此时也应该delete子类的内存空间(: perator delete(size))。

class x {
public:
static mem_out_handler set_handler(mem_out_handler p);
static void * operator new(size_t size);

private:
static mem_out_handler currenthandler;
};

mem_out_handler x::set_handler(mem_out_handler p)
{
mem_out_handler oldhandler = currenthandler;
currenthandler = p;
return oldhandler;
}
void * x: perator new(size_t size)
{
mem_out_handler globalhandler = std::set_new_handler(currenthandler);// 安装x的new_handler
void *memory;
try { // 尝试分配内存
memory = : perator new(size);
}
catch (std::bad_alloc& { // 恢复旧的new_handler
std::set_new_handler(globalhandler);
throw; // 抛出异常
}
std::set_new_handler(globalhandler); // 恢复旧的new_handler
return memory;
}
mem_out_handler x:currenthandler=NULL;

内存分配
static void nomorememory();// x的对象分配内存失败时调用的new_handler函数的声明

x::set_handler(nomorememory);// 把nomorememory设置为x的mem_out_handler函数
x *px1 = new x; // 如内存分配失败，调用nomorememory
x::set_handler(0); // 设x的mem_out_handler函数为空
x *px2 = new x; // 如内存分配失败，立即抛出异常。(类x当前没有mem_out_handler函数)

*********************************************************************************
可重用方法

定义
template
class base {
public:
static mem_out_handler set_handler(mem_out_handler p);
static void * operator new(size_t size);

private:
static mem_out_handler currenthandler;
};

template
mem_out_handler base::set_handler(mem_out_handler p)
{
mem_out_handler oldhandler = currenthandler;
currenthandler = p;
return oldhandler;
}

template
void * newhandlersupport: perator new(size_t size)
{
mem_out_handler globalhandler =
std::set_new_handler(currenthandler);
void *memory;
try {
memory = : perator new(size);
}
catch (std::bad_alloc& {
std::set_new_handler(globalhandler);
throw;
}

std::set_new_handler(globalhandler);
return memory;
}

template
mem_out_handler base::currenthandler=NULL;

//inheritance from mixin base class template.
class x: public base {
... // as before, but no declarations for set_handler or operator new
};

Note: redirecting output of an running process, not when starting a process, so '>' is ignored.
Take cat > /home/fist/output for example, this command would accept input of prompt, and write user inputs to the file "/home/fist/output".
What should we do , if we want to redirect the output of the program to another file, /home/fist/direct.txt for instance?
With the help of gdb, we can attach a running process, manipulating it's resources, passing messages, and invoking system calls in its' context.
As we know, there are three standard file: stdin, stdout and stderr, which are indexed by 0, 1 and 2 in a processes' context(0, 1, 2.etc are file descriptor). When we open a new file right after closing an existing one, the new file's descriptor would be just the same as the previous one. So, if we close stdout, and creat another one, the later one would use the file descriptor "1".
But how to close an existing file, and open another one? Follow me!
..............................................................................................
$ pgrep watch
3457
$ which watch
/usr/bin/watch
$ gdb -p 3457 /usr/bin/watch
...
(gdb) p close(1)
$1 = 0
(gdb) p creat("/home/fist/redirect", 0644)
$2 = 1
(gdb) quit
The program is running. Quit anyway(and detach it)?(y or n) y
Detaching from program: /usr/bin/watch, process 3457
..............................................................................................
The “p” command in GDB will print the value of an expression, an expression can be a function to call, it can be a system call… So I execute a close() system call and pass file handle 1, then I execute a creat() system call to open a new file. The result of the creat() was 1 which means that it replaced the previous file handle. If I wanted to use the same file for stdout and stderr or if I wanted to replace a file handle with some other number then I would need to call the dup2() system call to achieve that result.
To verify the result, we type some words into the session of cat, and see the content of /home/fist/redirect.You will see the difference.
Also, if you want to close the original session you need to close all file handles for it, open a new device that can be the controlling tty, and then call setsid().
..............................................................................................
[More]
Above method can be used to debug a running program ,by redirecting stdin, stdout and stderr to another session.The program can be a dameon, a program with no GUI interface, a console, etc.
Another advanced debugging method is signal. When programing, debug is planted in the program's gene.By sending,capturing and handling signal, more complicated debugging methods are supported.

http://en.wikipedia.org/wiki/Paxos_(computer_science)

Paxos 算法解决的问题是一个分布式系统如 何就某个值（决议）达成一致。一个典型的场景是，在一个分布式数据库系统中，如果各节点的初始状态一致，每个节点都执行相同的操作序列，那么他们最后能得 到一个一致的状态。为保证每个节点执行相同的命令序列，需要在每一条指令上执行一个“一致性算法”以保证每个节点看到的指令一致。这在节点可能无法连接的情况下变得更加困难。一个通用的一致性算法可 以应用在许多场景中，是分布式计算中的重要问题。因此从20世纪80年代起对于一致性算法的研究就没有停止过。节点通信存在两种模型：共享内存（Shared memory）和消息传递（Messages passing）。Paxos 算法就是一种基于消息传递模型的一致性算法。

场景定义：

将节点的角色分为 proposers，acceptors，和 learners（允许身兼数职）。proposers 提出决议，acceptors 批准决议，learners“学习”决议。

需求定义：

1. 决议（value）只有在被 proposers 提出后才能批准（未经批准的决议称为“提案（proposal）”）；
2. 在一次 Paxos 算法的执行实例中，只批准一个 Value；
3. learners 只能获得被批准（chosen）的 Value。

算法的内容：

proposer 提出一个提案前，首先要和足以形成多数派的 acceptors 进行通信，获得他们进行的最近一次批准活动的编号（prepare 过程），之后根据回收的信息决定这次提案的 value，形成提案开始投票。当获得多数 acceptors 批准后，提案获得通过，由 proposer 将这个消息告知 learner。这个简略的过程经过进一步细化后就形成了 Paxos 算法。

决议的提出与通过：

通过一个决议分为两个阶段：

1. prepare 阶段：
   1. proposer 选择一个提案编号 n 并将 prepare 请求发送给 acceptors 中的一个多数派；
   2. acceptor 收到 prepare 消息后，如果提案的编号大于它已经回复的所有 prepare 消息，则 acceptor 将自己上次的批准回复给 proposer，并承诺不再批准小于 n 的提案；
2. 批准阶段：
   1. 当一个 proposor 收到了多数 acceptors 对 prepare 的回复后，就进入批准阶段。它要向回复 prepare 请求的 acceptors 发送 accept 请求，包括编号 n 和根据 P2c 决定的 value（如果根据 P2c 没有决定 value，那么它可以自由决定 value）。
   2. 在不违背自己向其他 proposer 的承诺的前提下，acceptor 收到 accept 请求后即批准这个请求。

决议的发布：

一个显而易见的方法是当 acceptors 批准一个 value 时，将这个消息发送给所有 learner。但是这个方法会导致消息量过大。
由于假设没有 Byzantine failures，learners 可以通过别的 learners 获取已经通过的决议。因此 acceptors 只需将批准的消息发送给指定的某一个 learner，其他 learners 向它询问已经通过的决议。这个方法降低了消息量，但是指定 learner 失效将引起系统失效。
因此 acceptors 需要将 accept 消息发送给 learners 的一个子集，然后由这些 learners 去通知所有 learners。
但是由于消息传递的不确定性，可能会没有任何 learner 获得了决议批准的消息。当 learners 需要了解决议通过情况时，可以让一个 proposer 重新进行一次提案。注意一个 learner 可能兼任 proposer。

Progress 的保证：

根据上述过程当一个 proposer 发现存在编号更大的提案时将终止提案。这意味这提出一个编号更大的提案会终止之前的提案过程。如果两个 proposer 在这种情况下都转而提出一个编号更大的提案，就可能陷入活锁，违背了 Progress 的要求。这种情况下的解决方案是选举出一个 president，仅允许 president 提出提案。但是由于消息传递的不确定性，可能有多个 proposer 自认为自己已经成为 president。Lamport 在The Part-Time Parliament一文中描述并解决了这个问题。

在事件驱动的程序中，GUI视图需要响应object的状态变化，作出特定反应。当状态变化时，将对应的信息发送给接收者。
事件的来源有两类，一种是系统事件，例如鼠标键盘事件，qt获取到这些来自系统底层的消息，将它们转换成qt的事件，放入事件队列；另一种是应用程序事件，例如postEvent/sendEvent。
事件通过各种各样的方式在object间传递。QWidget通过QEvent发送给其他QObject，以相应鼠标或键盘操作；QObject之间可通过signal/slot机制进行事件处理。

2.事件处理流程

3.event loop

下面是一个典型的qt主程序示例：
int main(int argc, char * argv[]) {
QApplication myapp(argc, argv);
QWidget rootWidget;
setGui(&rootWidget);
rootWidget.show();
return myapp.exec();
};

	Every GUI, multithreaded, or event-driven Qt Application must have a QApplication object defined at the top of main().
	Show the widget on the screen.
	Enter an event loop.

当调用QApplication::exec()函数之后，程序就进入了event loop，接收、处理、分发各种事件，直到程序退出。QApplication::exec()的简化逻辑如下所示：
while ( !app_exit_loop ) {
while( !postedEvents ) {             processPostedEvents()       }
while( !qwsEvnts ){            qwsProcessEvents();   }
while( !postedEvents ) {             processPostedEvents()       }
}

4.事件处理和事件过滤方法

1）QEvent子类
qt4.*中继承自QEvent的子类有QTimerEvent, QMouseEvent, QWheelEvent, QTabletEvent, QKeyEvent, QFocusEvent, QPaintEvent, QMoveEvent, QResizeEvent, QCloseEvent, QIconDragEvent, QShowEvent, QHideEvent, QContextMenuEvent, QIMEvent, QDropEvent, QDragLeaveEvent, QChildEvent, QCustomEvent.
开发者可以通过重载QWidget和QObject提供的事件处理方法，来响应对应的事件。例如，重载QWidget::mousePressEvent ( QMouseEvent * e )之后，我们就可以自行处理窗体的鼠标点击事件。

2）QObject::event()
通过重载event()，可以在某些事件到达本实例的特定事件处理器之前处理他们。对于那些没有明确需要预先处理的事件，需要调用其基类的event()函数。

3）QObject event filter
QObject::installEventFilter ( const QObject * filterObj )方法将filterObj注册为本对象的事件监视对象，即所有本对象的事件都会发送到filterObj。filterObj在QObject::eventFilter(QObject *o, QEvent *e )方法中截获并过滤所有事件，重载此方法，在其中过滤特定的事件。在对特定事件进行过滤之后，eventFilter需要返回TRUE，若不需要过滤或者要将过滤后的事件继续传递下去，则返回FALSE，此时要保证不要delete掉事件e。
一个监视器可以监视多个QObject，一个QObject可以被多个监视器监视，如果QObject被多个监视器监视，则消息按照监视器被注册的顺序传递到各个监视器。

4）QApplication::notify()
Qt调用QApplication::notify( QObject * receiver, QEvent * e )方法将事件e发送到receiver。

5）注册QApplication的监视器
所有事件在被处理和过滤之前，将被此监视器过滤。