记得老师是这么描述摩尔定律 -“ 计算机芯片集成电路数量，每 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！