Java多线程编程，是并发编程的一种（另一种重要的并发编程是多进程编程）。我们写java程序一般是运行在同一个进程中的，所以可以简单的认为：并发编程=多线程编程，让写操作系统的人去关注多进程编程吧。多线程编程是一个重要的软件基础，不管你的代码是不是多线程，java程序运行在jvm中一定是多线程运行的：运行你的main方法的线程，以及一些后台守护线程，如垃圾收集等。虽然在我们平时的程序中很少直接用到多线程，但是一些重要的框架都要用到多线程的。比如java应用服务器，Servlet，以及其他的任何一个知名的框架。所以，学好多线程编程，对我们理解框架的实现，提高软件设计水平，以及写出更好的可扩展，可伸缩的软件具有非常重要的作用。
多线程编程是非常复杂的，主要体现在多线程程序非常容易引入bug，这些bug通常难以调试重现，同时是在程序在高并发高负载的时候偶然出现，而且很难重复出现，所以调试这些bug是一个很困难的事。既然难么困难，为什么要用多线程呢，单线程不也挺好的吗？明知山有虎，偏向虎山行？那是人家体现自己的勇气用的。采用多线程又有什么好处呢？总的来说，有以下两点好处：
1.速度。首先，现在多核CPU已经烂大街了，你的CPU如果还是单核的你都不好意思和人打招呼。采用多线程可以“充分”利用CPU的处理能力。其实，更重要的一点是，并发通常可以提高运行在单核处理器上的程序的性能。这听起来似乎违背直觉。导致这个现象产生的原因是阻塞。程序要很多的地方会产生阻塞，比如IO操作。此时单线程程序就会一直阻塞，直到线程的资源都就绪。这会大大浪费CPU的处理能力。
2.改进代码设计。面向对象就是要让程序以一种和自然世界相似的思维来设计程序，多线程编程可以以更加接近真实世界的方式来思维，使程序更加简单易懂。比如仿真，如果不采用多线程，基本上没法实现。
并发编程是软件设计的基础，是可以离开任何程序语言来独立研究的。但是笔者认为那是计算机科学家干的事，比如DougLea，Brian Goetz等，笔者窃认为自己还没有达到这种境界。所以笔者只有结合java来说说多线程编程。Java在语言层面就支持多线程，而且有大量的类库来用于多线程编程，所以可以轻松用java写出多线程程序，做到以前只有专家能做到的事（写出来的程序的质量当然有天渊之别，呵呵）。我觉得，java从以下三方面来支持多线程编程：
1. 多线程的实现机制。Java采用命令模式来实现多线程，即执行器+ 任务 的方式。
2.多线程的底层协调机制。从最基本的同步到各种用途的锁，让程序员精确控制线程之间的协作（合作和竞争）。
3.多线程的高层协调工具类。各种原子变量，非阻塞队列，同步容器，同步器，让线程和线程之间的协作更简单方便。
下面分别从这三方面来阐述java的多线程编程。
一． 多线程的实现机制
Thread，Executor，ExecutorService，Runnable，Callable，Future……..当笔者看到这么多的类时，感到一阵头皮发麻。相信很多同仁也有一样的感觉。其实不止多线程，IO系统啊，Socket编程啊，都会让人有这种感觉，许多初学者望而怯步。但是我们只要以设计模式的思想去思考这些系统的实现，然后用某个设计模式慢慢梳理看似乱成一锅的类和接口时，就会发觉这些类库设计得很精妙和优雅。甚至对SUN的那帮人产生那什么XXX江水XXX连绵不绝的敬仰（不得不说，在技术上，过度的个人崇拜是不好的）。比如，用装饰者模式来分析IO系统，把那一大堆分成资源流和过滤器流之后，整个IO系统就简单明了的多了。把java的网络编程分成底层的Socket编程和高层的URL编程之后，又有豁然开朗的感觉。那么多线程的这一大堆类和接口又有什么玄机呢？答。案。就。是。。。。。。命令模式！首先分清楚执行器和任务这两个概念。执行器就是执行任务的器（？）。任务就是具体要实现的功能，依附在执行器上得以执行（以上两概念纯属瞎掰，不必较真，大概理解就行）。Thread，Executor，ExecutorService等属于执行器，而Runnable，Callable，FutureTask属于任务。程序运行时需要创建一个执行器，若干任务，任务依附在执行器上，由执行器启动执行并控制任务。至于ThreadFactory和UnCaughtExceptionHandler是指定执行的方式以及抛出异常时的处理，可以分别学习。值得一提的是一个重要的类是Future，它可以实现线程有返回值。返回的结果就放在Future里面，随时可以用get（）来检查执行结果。还可以用cancel（）来对线程执行interrupt（），功能十分强大。
二． 多线程的底层协调机制
编写多线程程序最重要的一个问题是对共享资源（或者叫共享，可变的状态）的访问，访问共享资源也是线程间相互通信的简单方法。而多个线程一起访问共享资源，就要注意线程安全。编写线程安全的代码，本质上是管理对状态的访问，而且通常是共享的，可变的状态.所谓共享，是指一个变量可以被多个线程访问；所谓可变，是指变量在生命周期内可以给便。我们讨论的线程安全好像是关于代码的，但真正要做的，是在不可控制的并发访问中保护数据。
Java提供底层的协调机制，以控制对共享资源的访问。这里的协调，包括竞争，合作和通信。
竞争是通过锁来实现的，在访问资源之前要先取得锁，如果锁正被其他线程占有，那么本线程就会阻塞，直到取得锁。具体的实现方式有两种：
1. synchronized关键字。Synchronized的语义是想要执行被包围的代码块或方法，必须先取得它声明的那个对象锁。如果不能取得，线程到这里就阻塞，直到取得对象锁。至于这样做是否能够真正保护了共享资源的访问，synchronized关键字是不管的。需要由程序员自己来保证：确保共享资源是私有的，所有访问共享资源的地方都加上了synchronized关键字，而且使用的是同一个对象锁。Synchronized不仅能保证操作的原子性，还可以保证变量的可见性。而volatile仅能保证变量的可见性。（有关原子性和可见性不知道要放哪里，这里先提一下）
2.使用concurrent.lock。使用concurrent.lock不仅能实现synchronized的全部功能，而且能提供更好的性能和更精确的语义。比如，synchronized用的是互斥锁，仅能实现对资源的互斥访问，为concurrent.lock不仅有互斥锁，还有读写锁。把读锁和写锁分开，写锁相当于互斥锁，而读锁是共享的，可以让多线程同时读，以提高性能。
合作：线程之间的合作包括Object.wait/notify/notifyAll，Thread.interrupt，Condition.await/signal/signalAll。可以在资源未准备好时调用Object.wait()使当前线程进入阻塞，而其他线程在资源准备好时调用notify把所有在Object上阻塞的线程唤醒，进入可执行状态。Condition.await/signal/signalAll是jdk5提供的更加精细控制线程的类，可以组合不同的Condition来实现复杂的控制。
通信:线程之间的通信通过PipedReader /PipedWriter组合成管道对。不同线程的线程可以在上面读写，从而实现通信。程序员可以方便地利用它们来实现“生产者-消费者”模型。
三．多线程的高层协调工具类
用底层的协调机制可以灵活实现各种各样的需求，但这样容易出错，对程序员的要求很高。JDK1.5推出了很多高层的协调工具类，这些类让我们可以不用再用synchronized或者Lock来控制并发，只要简单实用它提供的容器，同步器等，就可以实现并发访问。主要的类也可以用竞争，合作及通信来划分。主要包括：
1.各种特定用途的容器，方便线程之间的通信。如BlockingQueue，DelayQueue，ConcurrentHashMap，CopyOnWriteArrayList等。
2. 线程安全的基本变量类，在包java.util.concurrent.atomic中提供。
3.各种用途的同步器synchronizer，如CountDownLatch，CyclicBarrier，Semaphore，Exchange。
4.计时。TimeUnit类为指定和控制基于超时的操作提供了多重粒度（包括纳秒级）。以代替简陋的Thread.sleep。
以下将分别介绍：（暂略）
附A：并发编程需要掌握的一些基本概念：
1. 摩尔定律：集成电路芯片上所集成的晶体管数量，越每隔18个月便会翻一番。
2.Amdahl定律：对计算机系统的某个部件采用优化措施后所获得的计算机性能的提高，依赖于这部分的执行时间在整个运行时间中所占的比率。
3.竞争条件：多个任务并发访问和操作同一数据且执行结果与访问的特定顺序有关，称为竞争条件。（多个任务竞争响应某个条件，因访问顺序不同产生冲突或不一致的情况）。比如“检查再运行”“惰性初始化”。
4. 原子操作：任务在执行过程中不能被打断的一序列操作
5. 复合操作：任务在执行过程中可以被打断的一序列操作
6.不变约束：不变式表达了对状态的约束，这些状态是应该符合这个约束的值的组合。不变式可以代表某种业务规则。
7. 先验条件：针对方法，规定了在条用方法之前必须为真的条件
8. 后验条件：针对方法，规定了在条用方法之后必须为真的条件
9. 原子性：（见原子操作）
10. 可见性：确保线程对变量的写入对其他线程是可见的。即刷新内存中的变量。
附B：参考资料：
1. Java编程思想 中文版 第四版 by Bruce Eckel
2. Java并发编程实践 中文版 by Brian Goetz,Doug Lea 等
风不懂云的漂泊，天不懂雨的落魄，眼不懂泪的懦弱，