从专科毕业以来，工作已有三年有余。转眼间，我将要离开长沙，前往杭州开始一段新的人生旅程。心情难免相当复杂，在这期间，发生了很多事情。随之，自己也改变了很多。

这三年，在长沙博赛软件公司任职。这里，员工待遇不错，工作相对轻松。更重要的是，同事之间关系简单并且和睦，这样的公司确实不多。

事实上，我几乎没有向朋友提起过，在这期间，我还在另外一家计算机培训公司做培训讲师，工作了差不多两年。有时，一天工作超过了16个小时，从早上6点到晚上10点，觉得很累。说出来可能没人不相信，当时我还在长沙大学读本科。时常受到老师的责骂，无论多么难听，我都能忍受。当然，不会去说这些知识对我没有价值或者已经知晓。

纸是包不住火，有些老师和同学知道我的情况。我只能在学校里面尽量隐瞒，因为一旦提到薪酬问题上，每个同学的反应会不同，更不要说老师。在学校里面从来不会炫耀，甚至不提到技术。完全没有必要。

能够的事情告诉你，你会知道的，反之亦然。正如这里，我在告诉大家发生了什么，而不是为了炫耀（炫耀是种心态的问题）。同时，也是向老师和同学们道歉，我有我的苦衷。

我的坚持，让我学业和事业得到平衡，尽管人比较累，但是我从来没有抱怨过。我记得有句这样的话，“年轻的时候不努力，怎么在40岁之后享受事业的成果”。这几年，尤为明显，整个社会都很浮躁。很多年轻人老抱怨。当然，可以抱怨大是大非的问题，但是总是抱怨不公平，而反思自己是不客观的。我的观点是，这个世界永远是灰色的，也没有绝对的公平，不要浪费时间去讨论它，因为它会自动变化的，每个阶段会呈现不同的状态。当不能改变的时候，只能适应它。抓紧时间，做好自己就很好了。

兴趣和激情是够支持我高强度工作的动力，我一直认为除了谋生以外，感兴趣是最关键的。个人观点，事业就是做自己在做想做的事情，职业则是在做谋生的事情。事业会带来财富和名望。

事业没有高低贵贱，但是适合与否只有自己知道。这就是我为什么选择离开的原因。虽然，马上要离开长沙博赛了，但是心中仍然有点不舍，同时我心存着感激，感谢那些曾经帮助过我的人。当然，两家公司的离开，有无奈的地方，也有惊人相似之处。对此，我不想说什么。如果我的离开，能够给其他人带来安稳，那么也不失为好事一件。同事一场，希望大家能够真正地好好工作，给自己和家庭带来安全感。

人生不能用简单地套用“设计图纸”，而是随着实际情况而制定，不至于计划赶不上变化。工作并不是我生活的全部。我不是那种天天喊事业的人，也是一个凡人。也会接触到柴米油盐，我也想有一个幸福家庭。自然面对房子问题，这是年轻人心中一块大石，尤其是像我这种父母没有积蓄的人。说良心话，我住了父母的房子，这也是一种“啃老”，只是程度问题。通过客观分析，在短期内得出房价不会大降。终于决定在4月份买房。我一直很幸运，通过我三年的积累和平时省吃俭用，凑齐了一套房子的首付款。不巧的是，国家出台楼市调控政策，其结果是把我所有的积蓄消耗尽了。选择房贷的年限是一门学问，不但要结合自己的经济实力，还要分析未来工资趋势，选择一种月供压力较小的方式。这样，清除了一大后顾之忧。至少，无论是否事业成功，至少我有了退路。

买房之后，为谋求更高的职业目标，接下来开始找工作。参加几家大公司的面试，这些公司社会招聘流程中，需要候选人经过4轮以上的面试。有时候，不得不相信命运，本人均在最后一面“神秘地”地被刷下来了。面试过程感觉良好，还得到了面试官肯定。也许是否极泰来，9月份，受邀淘宝网和支付宝（皆为阿里巴巴集团公司下的两家子公司）面试通知，终于在这次得到了回报。两家公司面试都通过了。当时脑中顿时想起《当幸福来敲门》那部电影。从失利到成功，我的心里素质变得更好了。相比我其他一些遭遇，也算不了什么的。感谢那些在我失利的时候，给我鼓励和帮助的朋友，尤其要感谢我的女朋友。

鱼和熊掌不能兼得，结合自己的实际情况和职业房展，接受了淘宝公司的Offer，在此，对于支付宝公司珍重人才表示感谢，特别是那个美女HR。最重要的是，认识了几个朋友。接下来，我希望在淘宝公司，通过自己的努力，事业上能够得到长远的发展。

人生的道路上总会面临抉择，有时候是主动的，有时却是被动的。不管怎样，学会怎么选择比学会如何努力要重要很多。正确的方向需要不断地识别和选择。只有在正确的方向上，那么不会感到迷茫和无助。强者运命，弱者命运。人生不少事情需要自己经营，无论是事业，还是爱情。

最后，提前向亲爱的博赛同事道别，祝大家能够事业有成，幸福安康。

     记得老师是这么描述摩尔定律 -“ 计算机芯片集成电路数量，每 18 个月翻一翻”。听过之后，我顿时感到神奇。神的地方是，不能理解为什么电脑电脑更新这么快。奇的地方，计算机芯片既然物质，那么肯定有极限，芯片数量级不可能会成数学规律增长。因此，我对这个预言一直抱有怀疑的态度。

     针对这个理论，世界芯片级巨头 Intel 相当地认可，毕竟摩尔其人也是 Intel 创建人之一。因此， Intel 芯片数量的规律非常贴近摩尔定律。

     在很大程度上，硬件执行速度决定了计算机的运行速度。那也就说，摩尔定律也影响着系统运行效率。众所周知，操作系统支持并发执行，不过在单处理器，宏观上是并行 ，但微观上是串行。在这种情况下，并行实现则是由 CPU 轮询的方式来执行任务，在用户感知下，是不会觉得延迟的。如果 CPU 处理的速度越快，因此， CPU 在任务之间切换的时间就越短，用户更加不会察觉。

     摩尔定律，可谓是成也 Intel ，败也 Intel 。由于开发成本和物理极限等原因，单处理器遇到了瓶颈， 摩尔定律也宣告失效。新的时代来临 - 多处理器时代。

笔者却认为摩尔定律就是一个“大忽悠”，无论是物理限制，还是计算机体系和脑力的局限性。正所谓英雄所见略同。不久前，微软创始人 - 盖茨兄弟，也赞同这种观点 。同时， Intel 这些公司，为了弥补技术革命上面的憋足，把这种摩尔意识强如植入了民众的大脑，这就不难解释，在 2005 年有一个公司叫 AMD 让 Intel 多么的狼狈，其中最有威慑力应属于 x64 架构。

     无论摩尔定律留下了什么，多处理器时代已经来临。

 上一篇：1.基础          下一篇：1.2  多处理器时代

当打破养生“神话”时，老百姓又“清醒”过来，被媒体玩弄到无以复加地步。知识匮乏和不求甚解，甚至怀疑精神都不具备，能不成为悲剧吗？

放眼IT领域，结果发现也是惊人的相似。

现代编程语言的发展，让这个行业的门槛越来越低。就语言发展角度而言，这是一种必然趋势。从从业人员的素质而言，注定了良莠不齐的现象。往往技术人员容易经不起“新技术”的“诱惑”，不断学习所谓新的“技术”。在Java领域，恐怕没有人不知道“SSH”框架的大名。框架成就了其作者，也成了一种文化。本人作为面试官时，当问到请描述一下以前项目的架构？总是能够听到类似于这样的答案-“系统采用SSH架构...”。也许面试必谈SSH，因此本人的简历很难吸引他人的眼球。

当我第一眼看到Spring，觉得它就是“玩具”，这样的言论也许会遭到Spring粉丝的口诛笔伐。当你能够反向思考的时，你的世界也会发生变化。Spring给我们带来了什么？依赖倒置，不等同于零依赖。轻浸入性，不等于没有浸入性。系统拆去Spring，虽然能够保证源代码兼容性（编译时不会遇到问题），可是那样系统等同于残废-留下了一堆没有关联对象。当然，目的并不在于花大力气来批评Spring，毕竟存在即理由，Spring还是有其优点-良好地编程风格和丰富的类库等。Struts和Hibernate也如此。作为专业从业人员，讨论“谁是谁非”是没有意义的。分析使用场景，才是有意义的，前提是你必须了解它的优缺点，并非迎合或奉承它，不要为了技术而技术。

当你厌倦了框架的重复劳动（重复的编码工作和大量新型框架重复发明轮子），也许你更加关注于原理性的东西，甚至是实现细节。那么，本系列的文章就很可能会适合你。

当我们刚接触某个事物时，倾听（观察）它，怀疑（分析）它，定位它。兼听则明，偏听则暗。

文章来源：作者的JavaEye Blog。

1.  基础    
    1.1  摩尔定律  

    1.2  多处理器时代
        1.2.1  对称多处理（ Symmetric Multi-Processor, a.k.a SMP）
        1.2.2  非对称多处理（ ASymmetric Multi-Processor, a.k.a ASMP）
        1.2.3  非统一内存访问（ a.k.a NUMA）

    1.3  共享内存（Shared Memory）

    1.4  CPU 缓存
        1.4.1  缓存一致性（Cache coherence）
        1.4.2  MESI协议（MESI protocol）

    1.5  线程
        1.5.1  起源（Source）
        1.5.2  优势（Advantages）
        1.5.3  类型（Types）
        1.5.4  模型（Models）
        1.5.5  实现（Implementations）
        1.5.6  安全（Security）

    1.6  内存模型  (Memory Model)
        1.6.1  可见性（Visibility）
        1.6.2  原子性（Atomicity）
        1.6.3  顺序性（Order）
    
    1.7  互斥（ Mutual Exclusion）
        1.7.1  阻塞同步（ Blocking Synchronization）
        1.7.1.1 临界区（Critical Section）
        1.7.1.2  锁（Lock）
            1.7.1.2.1  类型（Types）
            1.7.1.2.1.1  自旋锁（Spinning Lock）
            1.7.1.2.1.2  标签锁（Ticket Lock）
            1.7.1.2.1.3  偏向锁（Biased Lock）*
            1.7.1.2.2   数据库锁（Database Lock）*
                1.7.1.2.2.1   消极锁
                1.7.1.2.2.2   乐观锁
            1.7.1.2.3  问题（Problems)
                1.7.1.2.3.1  活锁（Live Lock）
                1.7.1.2.3.2  死锁（Dead Lock）
                1.7.1.2.3.3  优先级倒置（Priority Inversion）
                1.7.1.2.3.4  其他（Others）            

        1.7.2 非阻塞同步（Non-Blocking Synchronization）
            1.7.2.1  Wait-free算法
                1.7.2.1.1  比较交换算法（Compare-And-Swap, a.k.a CAS）
                1.7.2.1.2  连接加载/条件存储（Load-link/Store-conditional）
            1.7.2.1.3  ABA问题
            1.7.2.2  Lock-free
            1.7.2.3  Obstruction-free

        1.7.3  重进入（Reentrant）

        1.7.4  监视器（Monitor）
            1.7.4.1  等待和信号（Wait and Signal）
            1.7.4.2  条件变量（Condition Variable）

        1.7.5  信号灯（Semaphore）

        1.7.6  双检查锁（Double-Checked Locking, a.k.a DCL）

    1.8  内存栅栏（Memory Barrier/Fence)

    1.9  一致性模型（Consistency Model）
        1.9.1  原子一致性（ Atomic consistency）
        1.9.2  连续一致性（Sequential  Consistency）
        1.9.3  因果一致性（Causal Consistency）        
        1.9.4  释放一致性（Release Consistency）        
        1.9.5  最终一致性（Eventual Consistency）
        1.9.6  Delta一致性（Delta Consistency）        
        1.9.7  弱一致性（Weak Consistency）        
        

    1.10  并发控制（Concurrency Control）
        1.10.1  软件事务存储（Software Transactional Memory,a.k.a STM）
                 
2.  Java 基础
    2.1  Java同步原语
        2.1.1  synchronized关键字
        2.1.2  volatile 关键字
        2.1.3  CAS操作-AtomicX

    2.2  Java内存模型
        2.2.1  可见性（Visibility）
        2.2.2  原子性（Atomicity）
        2.2.3  顺序性（Order）
        2.2.4  Happens-Before

    2.3  java.lang.Thread
        2.3.1  状态（State）
        2.3.2  启动-Thread.start方法
        2.3.3  弃用Thread.stop, Thread.suspend 和 Thread.resume方法
        2.3.4  终止Thread.interrupt和Thread.interrupted方法
        2.3.5  Thread.join方法
        2.3.6  Object.wait/notify方法
        2.3.7  Thread.wait方法


3.  Java并发框架
    3.1J.U.C框架
        3.1.1  同步
            3.1.1.1  核心-AbstractQueuedSynchronizer
            3.1.1.2  重进入锁-ReentrantLock
            3.1.1.3  重进入读写锁-ReentrantReadWriteLock
            3.1.1.4  条件变量-Condition
            3.1.1.5  新通知/信号机制-LockSupport

        3.1.2  限制
            3.1.2.1  CountDownLatch
            3.1.2.2  CyclicBarrier
            3.1.2.3  信号灯（Semaphore）

        3.1.3  原子操作  
                  3.1.3.1  Atomic*类
                  3.1.3.2  操作实现-sun.misc.Unsafe

        3.1.4  线程安全集合
                  3.1.4.1  CopyOnWriteArrayList和CopyOnWriteArraySet
                  3.1.4.2  ConcurrentSkipListMap和ConcurrentSkipListSet
                  3.1.4.3  ConcurrentHashMap
                  3.1.4.4  ArrayBlockingQueue
                  3.1.4.5  LinkedBlockingQueue和ArrayBlockingDueue
                  3.1.4.5  PriorityBlockingQueue    

        3.1.5  线程池
                  3.1.5.1  Executor
                  3.1.5.2  ThreadPoolExecutor
                  3.1.5.3  Callable和Future
                  3.1.5.4  ScheduledExecutorService
                  3.1.5.5  Executors

4. JVM并发实现 **
    4.1  线程（Thread）实现
    4.2  监视器（Monitor）实现
    4.3  可见性实现
    4.4  原子性实现
    4.5  顺序性实现
    4.6  其他

说明：

    1. 在标题后面带有符号“*”，代表这个内容可能有点于偏离主题。带有“**”的内容，可能比较难以理解。

   2. 由于知识体系比较繁杂，组织起来比较宽难，因此目录结构很有可能不断地更新。该文章的Update部分或者标题也会同步更新。

    3.一旦章节的内容完结，目录会即时更新链接，请大家留意。

    4.作者能力和学识有限，如果读者还有更加感兴趣的议题，或者任何错误、意见和建议，不妨直接留言或者发邮件来讨论。如果能够合著的话，那是更加完美了。

    5.文章转载前，请联系文章的作者。

谢谢 ，EOF！