异步，同步，递归，循环，状态

int my_puts1(const char *str)
{

    int retval = 0;
    if (*str==0){

        fwrite(str++, 1, 1, stdout);

        retval = my_puts1(str)+1;

    }

    return retval;

}


int my_puts2(const char *str)
{
    const char *p;
    for (p=str; *p; p++)
      fwrite(p, 1, 1, stdout);
    return (p-str);
}

上面的代码对调用者来说，没什么区别(这里只讲设计，不讨论效率问题):
但是对于需要中途需要中断执行，然后保存断点的，显然my_puts2比方式my_puts1更好处理。

单线程, 同步-异步，多线程:

#include <stdio.h>
#include <process.h>
#include <windows.h>

#define MAX_BOOTUP 40
static int _gboot = 0;

static int bootup(int code, int tid)
{
    return printf("bootup-%d: %d\n", tid, code);
}

static void bootupd_single(void *n)
{
    int b;
    for (b=_gboot++; b<MAX_BOOTUP;
            b=_gboot++){
        bootup(b, (int)n);
    }
}

static void bootupd_multi(int cnt)
{
    int j;
    for (j=0; j<cnt; j++)
        _beginthread(bootupd_single, 0, (void*)j);
}

static void bootupd_receiver()
{
    int code;
    for (;;){
        boot_receive(&code);
        boot_answer(code, 0);
        printf("Hello World!\n");
    }
}

static void bootupd_sink()
{
    _beginthread(bootupd_receiver, 0, (void*)j);
    boot_send(0);
    boot_send(1);
    boot_send(2);
    boot_send(3);
}

int main(int argc, char *argv[])
{
    bootupd_single(0);
    printf("--------------------------\n");
    _gboot = 0;
    bootupd_multi(2);
    Sleep(1000);
    bootupd_sink();
    return 0;
}


各方式的执行的的顺序性，一次性不同。

线程 VS 回调(callback/handler)。
线程的start_routing通常只启动一次，回调callback/handler则要调用多次，因为重入性，回调函数最好能尽快的处理完并且减少状态记录性。滥用，乱用线程的除外(这种情况下，这些规则不适用)。