近期收到客户一个需求，我将该需求转述为下面这个等价的问题。

【问题】

    * 有一个产品包装系统S，为某种产品P提供产品包装服务;

    * 系统S由若干个处理节点组成，每个节点都可以单独处理组件;

    * 产品P的一个可出厂的成品由包装盒+N个产品组件组成，包装盒与产品组件上都贴有一个标签，该标签上包含该成品的唯一编号ID（一定时间范围内有效）、每个组件自己的序号(unit-num)以及成品的组件总个数(unit-total)。每个成品只有一个包装盒，该包装盒的组件序号为0。其中unit-num <= unit_total == N <= 32;

    * 某个成品的诸多组件是乱序到达S并由S送到产品包装工位的；当系统S第一次接收到一个成品的某个组件时，S会将一个包装盒贴上该组件对应的成品ID，并将其放在传送带上，传送给对应的组装工位；当系统S接收到同一成品的其他组件时，不再重新发放包装盒了；

    * 系统S具有剔除冗余组件的功能，如果某个成品的某个组件（序号为n）已经被S接收并送到指定包装位，后续若再出现同一成品的相同序号组件（可能是因为标签贴错导致），S将会将该冗余组件剔除出包装线;

    * 当某个成品的最后一个组件被S处理后，该成品的ID即告无效了，可以被后续成品重复使用了。

【解决思路】

这个问题中有几个关键功能点：

    * 每个成品只分配一个包装盒；

    * 支持剔重；

    * 当最后一个组件被处理后，成品ID被从系统中删除，可被后续成品重复使用。

这是一个典型的多个节点并发操作的一致性问题，我们初步考虑基于开源的Memcached的CAS服务去解决该问题，解决思路如下：

    a) S系统中的某个节点收到某成品的某个组件(unit_num = n)后，以ID为Key尝试获取成品的Value(以及item_cas值)；如果索引尚未在系统建立，那么创建索引，以ID为Key，Value为一整型字符串，初值为1<<(n-1)；并分配包装盒；

    b) 如果以成品ID为Key的索引已经建立，系统节点将组件的(1<<n)与Value进行“与操作”以判断该组件是否为重复组件，如果为1，则为重复组件；否则以(Value +  1 << (n-1))的值以及获得的item_cas发起cas操作；

    c) 如果cas操作成功，则数一下((Value +  1 << (n-1)) 中置位（=1）的bit个数，如果个数==unit-total，则删除索引；否则继续处理下一个组件；
        如果cas操作失败，则回到步骤a)。

【Demo代码】

/* pack_sys.c */

… …
#include <libmemcached/memcached.h>

static const char *product_id = "nexus5";
static const int component_in_total = 5;
static const int component_order[] = {2, 3, 1, 2, 5, 4};

//code from <Algorithms.for.Programmers.Ideas.and.Source.Code>
static inline unsigned long long
bit_count(unsigned long long x)
{
    x = (0x5555555555555555UL & x) + (0x5555555555555555UL & (x >> 1));
    x = (0x3333333333333333UL & x) + (0x3333333333333333UL & (x >> 2));
    x = (0x0f0f0f0f0f0f0f0fUL & x) + (0x0f0f0f0f0f0f0f0fUL & (x >> 4));
    x = (0x00ff00ff00ff00ffUL & x) + (0x00ff00ff00ff00ffUL & (x >> 8));
    x = (0x0000ffff0000ffffUL & x) + (0x0000ffff0000ffffUL & (x >> 16));
    x = (0x00000000ffffffffUL & x) + (0x00000000ffffffffUL & (x >> 32));
    return x;
}

int
main(int argc, char *argv[])
{
    memcached_st *memc;
    memcached_return_t rc = MEMCACHED_SUCCESS;
    memcached_server_st *server = NULL;

    memc = memcached_create(NULL);
    if (NULL == memc) {
        printf("memcached_create error\n");
        return -1;
    }

    … …

    rc = memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, 1);
    if (rc != MEMCACHED_SUCCESS) {
        printf("memcached_behavior_set support cas error: %s\n",
                memcached_strerror(memc, rc));
        return -1;
    }

    /* pack the component one by one */
    int ret = 0;
    int i = 0;
    for (i = 0; i < sizeof(component_order)/sizeof(component_order[0]); i++) {
        ret = pack_component(memc, component_order[i]);
        if (ret == 0) {
            printf("pack component [%d] ok\n”, component_order[i]);
        } else if (ret == 1) {
            printf("pack component [%d] exists\n”, component_order[i]);
        } else {
            printf("other error occurs\n");
            return -1;
        }
        getchar();
    }

    return 0;
}

int
pack_component(memcached_st *memc, int i)
{
    memcached_return_t rc = MEMCACHED_SUCCESS;

    uint32_t mask = 1 << (i – 1);
    uint32_t value_added = 1 << (i – 1);
    char value_added_str[11] = {0};
    uint32_t value = 0;
    char *pvalue = NULL;
    size_t value_len = 0;
    uint32_t flags = 0;

    while(1) {
        pvalue = memcached_get(memc, product_id, strlen(product_id),
                               &value_len, &flags, &rc);
        if (!pvalue) {
            if (rc == MEMCACHED_NOTFOUND) {
                printf("componet [%d] – memcached_get not found product key: [%s]\n",
                       i, product_id);
                memset(value_added_str, 0, sizeof(value_added_str));
                sprintf(value_added_str, "%u", value_added);
                rc = memcached_add(memc, product_id, strlen(product_id), value_added_str,
                                   strlen(value_added_str), 1000, 0);
                if (rc == MEMCACHED_DATA_EXISTS) {
                    printf("componet [%d] – memcached_add key[%s] exist\n", i, product_id);
                    pvalue = memcached_get(memc, product_id, strlen(product_id),
                                           &value_len, &flags, &rc);
                    if (!pvalue) return -1;
                } else if (rc != MEMCACHED_SUCCESS) {
                    printf("componet [%d] – memcached_add error: %s, [%d]\n",
                            i, memcached_strerror(memc, rc), rc);
                    return -1;
                } else {
                    printf("componet [%d] – memcached_add key[%s] successfully,"
                           " its value = %u, cas = %llu\n",
                            i,product_id,
                            value_added, (memc->result).item_cas);
                    return 0;
                }
            } else {
                printf("componet [%d] – memcached_get error: %s, %d\n",
                       i, memcached_strerror(memc, rc), rc);
                return -1;
            }
        }

        value = atoi(pvalue);
        printf("componet [%d] – memcached_get value = %u, cas = %llu\n",
                i, value, (memc->result).item_cas);

        if (value & mask) {
            free(pvalue);
            return 1;
        } else {
            uint64_t cas_value = 0;
            cas_value = (memc->result).item_cas;
            memset(value_added_str, 0, sizeof(value_added_str));
            sprintf(value_added_str, "%d", value_added + value);

            rc = memcached_cas(memc, product_id, strlen(product_id),
                               value_added_str, strlen(value_added_str),
                               1000, 0, cas_value);
            if (rc != MEMCACHED_SUCCESS) {
                printf("componet [%d] -  memcached_cas error = %d,  %s\n",
                        i, rc, memcached_strerror(memc, rc));
                free(pvalue);
            } else {
                printf("componet [%d] -  memcached_cas ok\n", i);
                free(pvalue);
                if (bit_count(value_added + value) == component_in_total) {
                    rc = memcached_delete(memc, product_id, strlen(product_id), 0);
                    if (rc != MEMCACHED_SUCCESS) {
                        printf("memcached_delete error: %s\n",
                                memcached_strerror(memc, rc));
                        return -1;
                    } else {
                        printf("memcached_delete key: %s ok\n", product_id);
                    }
                }
                return 0;

            }
        }
        getchar();
    }

    return 0;
}

代码看起来较多，主要是要考虑各种异常情况。

我们可以通过先后启动两个pack_sys来验证程序逻辑的正确性：

窗口1：
$> pack_sys
componet [2] – memcached_get not found product key: [nexus5]
componet [2] – memcached_add key[nexus5] successfully, its value = 2, cas = 0
pack component [2] ok

窗口2：
$> pack_sys
componet [2] – memcached_get value = 2, cas = 54
pack component [2] exists

若两个窗口继续交替执行，一种可能的结果如下：

窗口1：

$> pack_sys
componet [2] – memcached_get not found product key: [nexus5]
componet [2] – memcached_add key[nexus5] successfully, its value = 2, cas = 0
pack component [2] ok

componet [3] – memcached_get value = 2, cas = 54
componet [3] -  memcached_cas ok
pack component [3] ok

componet [1] – memcached_get value = 6, cas = 55
componet [1] -  memcached_cas ok
pack component [1] ok

componet [2] – memcached_get value = 23, cas = 57
pack component [2] exists

componet [5] – memcached_get not found product key: [nexus5]
componet [5] – memcached_add key[nexus5] successfully, its value = 16, cas = 0
pack component [5] ok

componet [4] – memcached_get value = 16, cas = 59
componet [4] -  memcached_cas ok
pack component [4] ok

窗口2：

$> pack_sys
componet [2] – memcached_get value = 2, cas = 54
pack component [2] exists

componet [3] – memcached_get value = 7, cas = 56
pack component [3] exists

componet [1] – memcached_get value = 7, cas = 56
pack component [1] exists

componet [2] – memcached_get value = 7, cas = 56
pack component [2] exists

componet [5] – memcached_get value = 7, cas = 56
componet [5] -  memcached_cas ok
pack component [5] ok

componet [4] – memcached_get value = 23, cas = 57
componet [4] -  memcached_cas ok
memcached_delete key: nexus5 ok
pack component [4] ok

全部Demo代码已经上传到github上了，感兴趣可以去下载。

【其它】

* 我用的是libmemcached 1.0.17版本，memcached 1.4.15版本。

* libmemcached启用cas后，只能在ascii模式下工作，在binary下会得到如下错误，应该是libmemcached的bug；

     memcached_cas error,  SERVER END, 21 

* libmemcached的官方文档中某些内容似乎已经落伍了，与代码的实际行为已经不一致了，参考manual的时候要小心，最好能对着源码看。

* 关于问题调试，可以考虑通过-vv命令行选项打开memcached的详细日志，这样你就可以看到memcached的一举一动，特别是涉及到binary protocol时，这样调试更有效率。

有一段时间，我完全沉迷于在脑海中想象机械绘图和设计新机型所带来的极致享受，这是我一生中有过的最完美的精神愉悦。创造的灵感像泉水般源 源不断 地涌出，我遇到的唯一困难就是必须设法牢牢抓住它们。对我来说，构思中的设备零件都绝对是真实的，所有细节都触手可及，甚至最细微的标识和磨损状态也是如 此。想象发动机在持续不断地运转，仿佛一道迷人的风景呈现在面前，令我欣喜若狂。
                                                                                                        — 尼古拉. 特斯拉

看完上面这段特斯拉回忆录中的自述后，我们不禁惊叹于特斯拉超乎寻常的大脑构思能力。读完特斯拉的回忆录《被世界遗忘的天才：特斯拉回忆录》后， 我完完全全相信特斯拉是一个不折不扣的“外星人”，就是像克拉克.肯特那样被送到地球的“超人”。不同于超人的是他给地球带来的不是钢铁般的身躯和无比的 正义，而是超级智慧。他的所思所想所做所为完全超越了那个时代，甚至是当今的时代。作为程序员，我们不敢奢望能拥有特斯拉那样的超级构思力，但拥有一个良 好的构思力对于程序员来说还是蛮重要的。

【什么是构思力】

就我自己的认知和经验来说，构思力是一种“在大脑中构造事物的能力”，构造出的事物不是静态的，它在你的构思下不断演化，像是一部电影。日常生活工作中， 绝大部分人都是被动构造，当收到外界的输入时，包括影像、声音、感悟等时，在大脑中应激性的出现一些事物和场景。这种构思的持续时间很短，从长度上来说， 都是微电影，并且很难抓住并转换为现实，价值不大。真正的有价值的构思应该是主动、有意识、有目的地在大脑中构造。因此构思力常用于在创造、创作以及发明 的过程中，各个行业莫不如此。

【构思 vs. 设计】

构思与设计都需要经过脑力完成，甚为相似，难于区分，但个人觉得还是有些许差别。就就像特斯拉回忆录里描述的那种情形，我们称之为构思。构思强调事物从无到有， 都在脑中完成，是一种全脑演算。有时就是一个闪念，瞬间迸发出来，很迅速，并可被快速捕捉到，构思者往往会变得热情高涨，并在短时间内完成主体设计和实 现。构思往往一次成型，多用于整体或全局设计，是真正设计阶段开始的前置条件。构思过程会将事物的全貌在大脑中构造出来；将关键的技术难点在脑中完成突 破，形成思路；会将事物与外围接口在脑中进行对接；会对创造出来的事物在脑中进行初步的验证，证明其正确性。

设计则会将前期构思的事物分解并细化，落于纸面，或画出各种图形，多是渐进和迭代的；有时用作局部优化。

因此可以看出，构思是更高层次的设计。

【程序员与构思】

程序员的日常工作与创造关系紧密，而“创新”则离不开构思。哪些工作属于构思范畴呢？目前看来比例不多，在目前这个网络四通八达发达，搜索引擎智能强大的 时代，你要的解决方案基本都能在Internet上找到，只是将现成的方案挪到你的solution中，我觉得算不上构思，顶多是设计，设计如何将现有的 东西组合起来。

构思的结果是崭新的方案或是基于已有方案的优化改进，是有脑力参与的事物演化。但构思不是必须凭空创造，多是站在巨人的肩膀上，是个借鉴再创新的过程。构思有时候可能有“重新发明轮子的味道“，但重造轮子不一定不好。

构思可大可小，Linus Torvalds设计并实现Git、Matz发明Ruby等属于大构思，你将某个算法的性能提升20%可算作小构思。

在软件开发领域，构思不是技术领域专有的，业务流程或过程的创新都与构思不无关系。

Non-trivial的开源项目多是构思的结果。我个人在开源lcut, cbehave, buildc时也是深有体会的。当大脑中构思演化出目标图景时，人会变得极为亢奋，软件的主体架子在短短几个小时或一两天内就完成了。很多著名的开源项目也是如此。

【影响构思力的几个因素】

构思力高低要看大脑的活力。个人理解影响构思力高低的几个因素：

    * 脑部成像构造能力
      
        就像特斯拉那样，每个人脑部都有一定的事物成像能力，比如提到神舟发射，你脑中会呈现某种画面；再比如提到Google数据中心，你脑中又会出现何种场 景。当然这些例子还都是简单的事物还原能力。当提到让你改进神舟飞船或降低Google数据中心能耗时，你的脑中的画面会有怎样的变化呢？能否变化或能否 沿着对应的问题演化能反映出构思能力的高低。当然这是需要有领域知识、眼光和技能的。改进的神舟飞船与降低了能耗的Google数据中心是不存在的，需要 你使用纯粹的空想构造能力对其进行演进的。训练你的脑部构造能力，要求你日常勤于用脑，勤于思考，经常将各种信号输入（语言、声音、感觉）进行转换，在脑 中尝试成像，减少视觉信号的输入。记得小时候印象最深的一件事就是一边听着单田芳老师的评书，一边在大脑中构造对应的场面、人物形象和情节，我想这对我大 脑的构思成像能力是大有裨益的。

    * 知识与眼光的广博
       
        凭空的构思创造毕竟是少数，而多是站在巨人的肩膀上。这要求你对所属领域甚是是相关领域有一定的了解和认知，这样在构思时，才能如特斯拉那样思如泉涌，思想的碰撞火花四溅。这就像拍摄电影，需要在日常积累各种素材和技法，兼容并序。

    * 对问题域的透彻理解

        构思多是行业领域相关的，构思的结果都是隶属于某个领域或行业的。构思出的方案是为了解决一个明确的问题或满足特定需求，因此是否对问题有透彻的理解将直接影响构思过程和结果，以及你构思力的发挥。

以上关于构思力的论述感觉还不够系统成熟，仅是一些主观心得体会罢了，供参考并欢迎交流。