从四个方面来说:
1、消息发送
2、工作线程控制
3、信箱调度
4、消息分发
与调度相关的代码实现在/skynet-src/skynet_mq.c,/skynet-src/skynet_start.c,/skynet-src/skynet_server.c三个文件中，整体上是一个m:n的调度器。
消息发送
skynet的消息定义在/skynet-src/skynet_mq.h中：
struct skynet_message {
uint32_t source;
int session;
void * data;
size_t sz;
};
// type is encoding in skynet_message.sz high 8bit
#define MESSAGE_TYPE_MASK (SIZE_MAX >> 8)
#define MESSAGE_TYPE_SHIFT ((sizeof(size_t)-1) * 8)
source:消息源(sc)的句柄。
session:用来做上下文的标识
data:消息指针
sz:消息长度,消息的请求类型定义在高8位
消息发出后，会被保存在接收者sc的信箱(message_queue字段)中，发送消息也就是向信箱压入一条消息。来看看发送函数吧，在/skynet-src/skynet_server.c中：
1 int
2 skynet_send(struct skynet_context * context, uint32_t source, uint32_t destination , int type, int session, void * data, size_t sz) {
3 if ((sz & MESSAGE_TYPE_MASK) != sz) {
4 skynet_error(context, "The message to %x is too large", destination);
5 if (type & PTYPE_TAG_DONTCOPY) {
6 skynet_free(data);
7 }
8 return -1;
9 }
10 _filter_args(context, type, &session, (void **)&data, &sz);
11
12 if (source == 0) {
13 source = context->handle;
14 }
15
16 if (destination == 0) {
17 return session;
18 }
19 if (skynet_harbor_message_isremote(destination)) {
20 struct remote_message * rmsg = skynet_malloc(sizeof(*rmsg));
21 rmsg->destination.handle = destination;
22 rmsg->message = data;
23 rmsg->sz = sz;
24 skynet_harbor_send(rmsg, source, session);
25 } else {
26 struct skynet_message smsg;
27 smsg.source = source;
28 smsg.session = session;
29 smsg.data = data;
30 smsg.sz = sz;
31
32 if (skynet_context_push(destination, &smsg)) {
33 skynet_free(data);
34 return -1;
35 }
36 }
37 return session;
38 }
3-9行对消息长度做了限制，MESSAGE_TYPE_MASK等于（SIZE_MAX >> 8）,也就是最大只能为224，16MB。
_filter_args根据type做了两个处理：
1、(type & PTYPE_TAG_DONTCOPY) == 0
会将data复制一份用作实际发送,这种情况下原来的data就要由调用者负责释放。
2、(type & PTYPE_TAG_ALLOCSESSION) > 0
会从sc的session计数器分配一个session.
处理完后，type会合并到sz的高8位。
最后一步就是投递到接收者的信箱了，根据接收者句柄判断是否为远程节点，如果是就用harbo发送。(内置的集群方案，现在已经不推荐使用)。成功返回session,失败返回-1,并且释放data.
工作线程的控制
skynet运行后，会启动固定的线程来轮流调度sc(skynet_context),线程数由配置文件中的thread字段定义，默认是4个。那它是如何控制这些线程的呢？具体实现在/skynet-src/skynet_start.c中。
在208行，启动了工作线程：
static int weight[] = {
-1, -1, -1, -1, 0, 0, 0, 0,
1, 1, 1, 1, 1, 1, 1, 1,
2, 2, 2, 2, 2, 2, 2, 2,
3, 3, 3, 3, 3, 3, 3, 3, };
struct worker_parm wp[thread];
for (i=0;i<thread;i++) {
wp[i].m = m;
wp[i].id = i;
if (i < sizeof(weight)/sizeof(weight[0])) {
wp[i].weight= weight[i];
} else {
wp[i].weight = 0;
}
create_thread(&pid[i+3], thread_worker, &wp[i]);
}
直接来看线程函数thread_worker把，在152行：
1 static void *
2 thread_worker(void *p) {
3 struct worker_parm *wp = p;
4 int id = wp->id;
5 int weight = wp->weight;
6 struct monitor *m = wp->m;
7 struct skynet_monitor *sm = m->m[id];
8 skynet_initthread(THREAD_WORKER);
9 struct message_queue * q = NULL;
10 while (!m->quit) {
11 q = skynet_context_message_dispatch(sm, q, weight);
12 if (q == NULL) {
13 if (pthread_mutex_lock(&m->mutex) == 0) {
14 ++ m->sleep;
15 // "spurious wakeup" is harmless,
16 // because skynet_context_message_dispatch() can be call at any time.
17 if (!m->quit)
18 pthread_cond_wait(&m->cond, &m->mutex);
19 -- m->sleep;
20 if (pthread_mutex_unlock(&m->mutex)) {
21 fprintf(stderr, "unlock mutex error");
22 exit(1);
23 }
24 }
25 }
26 }
27 return NULL;
28 }
控制这种生命周期与进程一致的工作线程，主要有两个细节：1、均匀不重复的分配任务。2、不空转、最小时延。前者处理线程同步就好。来看看skynet是如何处理后者的吧:
它用得是条件变量来处理空转的，用条件变量有两点好处：1、让出cpu时间片.2、由外部决定何时唤醒，这样可以在有任务时再唤醒，既能最大化的不空转，又能减小处理任务的时延。
具体实现是条件变量的标准应用了，和《unix高级编程》条件变量的例子几乎一样。这里还有一个sleep的计数，有什么用呢？用来判断要不要调用pthread_cond_signal的。
最后还有一个问题，等待的线程是在哪里被唤醒的呢？在socket线程和timer线程里唤醒的，前者有socket消息时会调用一次，后者每个刷新时间会唤醒一次。
信箱的调度
上一篇时，在sc里我们看到过一个message_queue类型的字段，这就是信箱。skynet中用了两种队列来存储消息并完成调度，下面称为12级队列，1级队列是一个单链表，每个节点是2级队列，2级队列(message_queue)是一个自动扩展的循环队列，用来存储消息。这两个队列实现在/skynet-src/skynet_mq.c中，实现的很简单，并没有用复杂的无锁结构，而是自旋锁保证线程安全的链表，循环队列。
信箱的调度就是12级队列的调度，整体结构描述如下：
while(1){
1级队列出队；
调度2级队列；
1级队列入队；
}
这部分实现在/skynet-src/skynet_server的275行skynet_context_message_dispatch()中：
1 struct message_queue *
2 skynet_context_message_dispatch(struct skynet_monitor *sm, struct message_queue *q, int weight) {
3 if (q == NULL) {
4 q = skynet_globalmq_pop();
5 if (q==NULL)
6 return NULL;
7 }
8
9 uint32_t handle = skynet_mq_handle(q);
10
11 struct skynet_context * ctx = skynet_handle_grab(handle);
12 if (ctx == NULL) {
13 struct drop_t d = { handle };
14 skynet_mq_release(q, drop_message, &d);
15 return skynet_globalmq_pop();
16 }
17
18 int i,n=1;
19 struct skynet_message msg;
20
21 for (i=0;i<n;i++) {
22 if (skynet_mq_pop(q,&msg)) {
23 skynet_context_release(ctx);
24 return skynet_globalmq_pop();
25 } else if (i==0 && weight >= 0) {
26 n = skynet_mq_length(q);
27 n >>= weight;
28 }
29 int overload = skynet_mq_overload(q);
30 if (overload) {
31 skynet_error(ctx, "May overload, message queue length = %d", overload);
32 }
33
34 skynet_monitor_trigger(sm, msg.source , handle);
35
36 if (ctx->cb == NULL) {
37 skynet_free(msg.data);
38 } else {
39 dispatch_message(ctx, &msg);
40 }
41
42 skynet_monitor_trigger(sm, 0,0);
43 }
44
45 assert(q == ctx->queue);
46 struct message_queue *nq = skynet_globalmq_pop();
47 if (nq) {
48 // If global mq is not empty , push q back, and return next queue (nq)
49 // Else (global mq is empty or block, don't push q back, and return q again (for next dispatch)
50 skynet_globalmq_push(q);
51 q = nq;
52 }
53 skynet_context_release(ctx);
54
55 return q;
56 }
这个函数的作用是,调度传入的2级队列，并返回下一个可调度的2级队列。在上面的实现中，有四个细节之处：
1、22-24行，当2级队列为空时并没有将其压入1级队列，那它从此就消失了吗？不，这样做是为了减少空转1级队列，那这个2级队列是什么时候压回的呢？在message_queue中，有一个
in_global标记是否在1级队列中，当2级队列的出队(skynet_mq_pop)失败时，这个标记就会被置0,在2级队列入队时(skynet_mq_push)会判断这个标记，如果为0，那么就会将自己压入1级队列。(skynet_mq_mark_release也会判断)所以这个2级队列在下次入队时会压回。
2、25-27,修改了for循环的次数，也就是每次调度处理多少条消息。这个次数与传入的weight有关，我们回过头来看这个weight是从哪里来的，源头在工作线程创建时：
static int weight[] = {
-1, -1, -1, -1, 0, 0, 0, 0,
1, 1, 1, 1, 1, 1, 1, 1,
2, 2, 2, 2, 2, 2, 2, 2,
3, 3, 3, 3, 3, 3, 3, 3, };
struct worker_parm wp[thread];
for (i=0;i<thread;i++) {
wp[i].m = m;
wp[i].id = i;
if (i < sizeof(weight)/sizeof(weight[0])) {
wp[i].weight= weight[i];
} else {
wp[i].weight = 0;
}
create_thread(&pid[i+3], thread_worker, &wp[i]);
}
再来看看 n >>= weight,嗯，大致就是：把工作线程分为组，前四组每组8个，超过的归入第5组，AE组每次调度处理一条消息,B组每次处理(n/2)条，C组每次处理(n/4)条，D组每次处理(n/8)条。是为了均匀的使用多核。
3、29-32做了一个负载判断，负载的阀值是1024。不过也仅仅是输出一条log提醒一下而以.
4、34、42触发了一下monitor,这个监控是用来检测消息处理是否发生了死循环，不过也仅仅只是输出一条log提醒一下。这个检测是放在一个专门的监控线程里做的，判断死循环的时间是5秒。具体机制这里就不说了，其实现在/skynet-src/skynet_monitor.c中
消息分发
信箱调度时，从2级队列取出消息后就会调用dispatch_message函数做分发，在/skynet-src/skynet_server.c中：
1 static void
2 dispatch_message(struct skynet_context *ctx, struct skynet_message *msg) {
3 assert(ctx->init);
4 CHECKCALLING_BEGIN(ctx)
5 pthread_setspecific(G_NODE.handle_key, (void *)(uintptr_t)(ctx->handle));
6 int type = msg->sz >> MESSAGE_TYPE_SHIFT;
7 size_t sz = msg->sz & MESSAGE_TYPE_MASK;
8 if (ctx->logfile) {
9 skynet_log_output(ctx->logfile, msg->source, type, msg->session, msg->data, sz);
10 }
11 if (!ctx->cb(ctx, ctx->cb_ud, type, msg->session, msg->source, msg->data, sz)) {
12 skynet_free(msg->data);
13 }
14 CHECKCALLING_END(ctx)
15 }
step1:将sc句柄保存在线程本地变量中.
step2:如果开启了录像功能，就将data的数据dump到日志文件
step3:调用sc的回调函数,根据返回值觉得是否释放data,0释放，1不释放.