关于多线程的知识，有非常多的资料可以参考。这里稍微总结一下，以求加深记忆。

关于多线程在日常工作中的使用：对于大多数的日常应用系统，比如各种管理系统，可能根本不需要深入了解，仅仅知道Thread/Runnable就够了；如果是需要很多计算任务的系统，比如推荐系统中各种中间数据的计算，对多线程的使用就较为频繁，也需要进行一下稍微深入的研究。

ThreadLocal与synchronized

区别ThreadLocal 与 synchronized

ThreadLocal是一个线程隔离(或者说是线程安全)的变量存储的管理实体（注意：不是存储用的），它以Java类方式表现； 

synchronized是Java的一个保留字，只是一个代码标识符，它依靠JVM的锁机制来实现临界区的函数、变量在CPU运行访问中的原子性。 

两者的性质、表现及设计初衷不同，因此没有可比较性。

synchronized对块使用，用的是Object对象锁，对于方法使用，用的是this锁，对于静态方法使用，用的是Class对象的锁，只有使用同一个锁的代码，才是同步的。

理解ThreadLocal中提到的变量副本

事实上，我们向ThreadLocal中set的变量不是由ThreadLocal来存储的，而是Thread线程对象自身保存。

当用户调用ThreadLocal对象的set(Object o)时，该方法则通过Thread.currentThread()获取当前线程，将变量存入Thread中的一个Map内，而Map的Key就是当前的ThreadLocal实例。

Runnable与Thread

实现多线程，Runnable接口和Thread类是最常用的了，实现Runnable接口比继承Thread类会更有优势：

• 适合多个相同的程序代码的线程去处理同一个资源
• 可以避免java中的单继承的限制
• 增加程序的健壮性，代码可以被多个线程共享，代码和数据独立。

Java线程阻塞

阻塞指的是暂停一个线程的执行以等待某个条件发生（如某资源就绪）。Java 提供了大量方法来支持阻塞，下面让对它们逐一分析。

1、sleep()方法：sleep()允许指定以毫秒为单位的一段时间作为参数，它使得线程在指定的时间内进入阻塞状态，不能得到CPU 时间，指定的时间一过，线程重新进入可执行状态。

典型地，sleep() 被用在等待某个资源就绪的情形：测试发现条件不满足后，让线程阻塞一段时间后重新测试，直到条件满足为止。

2、（Java 5已经不推荐使用，易造成死锁！！） suspend()和resume()方法：两个方法配套使用，suspend()使得线程进入阻塞状态，并且不会自动恢复，必须其对应的 resume() 被调用，才能使得线程重新进入可执行状态。典型地，suspend() 和 resume() 被用在等待另一个线程产生的结果的情形：测试发现结果还没有产生后，让线程阻塞，另一个线程产生了结果后，调用resume()使其恢复。

stop()方法，原用于停止线程，也已经不推荐使用，因为stop时会解锁，可能造成不可预料的后果；推荐设置一个flag标记变量，集合interrupt()方法来让线程终止。

3.、yield() 方法：yield() 使得线程放弃当前分得的 CPU 时间，但是不使线程阻塞，即线程仍处于可执行状态，随时可能再次分得 CPU 时间。调用 yield() 的效果等价于调度程序认为该线程已执行了足够的时间从而转到另一个线程。

4.、wait() 和 notify() 方法：两个方法配套使用，wait() 使得线程进入阻塞状态，它有两种形式，一种允许指定以毫秒为单位的一段时间作为参数，另一种没有参数，前者当对应的 notify() 被调用或者超出指定时间时线程重新进入可执行状态，后者则必须对应的 notify() 被调用。

2和4区别的核心在于，前面叙述的所有方法，阻塞时都不会释放占用的锁（如果占用了的话），而这一对方法则相反。上述的核心区别导致了一系列的细节上的区别。

首先，前面叙述的所有方法都隶属于Thread 类，但是这一对却直接隶属于 Object 类，也就是说，所有对象都拥有这一对方法。因为这一对方法阻塞时要释放占用的锁，而锁是任何对象都具有的，调用任意对象的 wait() 方法导致线程阻塞，并且该对象上的锁被释放。而调用任意对象的notify()方法则导致因调用该对象的 wait() 方法而阻塞的线程中随机选择的一个解除阻塞（但要等到获得锁后才真正可执行）。

其次，前面叙述的所有方法都可在任何位置调用，但是这一对方法却必须在 synchronized 方法或块中调用，理由也很简单，只有在synchronized 方法或块中当前线程才占有锁，才有锁可以释放。同样的道理，调用这一对方法的对象上的锁必须为当前线程所拥有，这样才有锁可以释放。因此，这一对方法调用必须放置在这样的 synchronized 方法或块中，该方法或块的上锁对象就是调用这一对方法的对象。若不满足这一条件，则程序虽然仍能编译，但在运行时会出现 IllegalMonitorStateException 异常。

wait() 和 notify() 方法的上述特性决定了它们经常和synchronized 方法或块一起使用，将它们和操作系统的进程间通信机制作一个比较就会发现它们的相似性：synchronized方法或块提供了类似于操作系统原语的功能，它们的结合用于解决各种复杂的线程间通信问题。

关于 wait() 和 notify() 方法最后再说明两点：

　　第一：调用 notify() 方法导致解除阻塞的线程是从因调用该对象的 wait() 方法而阻塞的线程中随机选取的，我们无法预料哪一个线程将会被选择，所以编程时要特别小心，避免因这种不确定性而产生问题。

　　第二：除了 notify()，还有一个方法 notifyAll() 也可起到类似作用，唯一的区别在于，调用 notifyAll() 方法将把因调用该对象的wait()方法而阻塞的所有线程一次性全部解除阻塞。当然，只有获得锁的那一个线程才能进入可执行状态。

线程是JVM级别的

我们知道静态变量是ClassLoader级别的，如果Web应用程序停止，这些静态变量也会从JVM中清除。

但是线程则是JVM级别的，如果用户在Web应用中启动一个线程，这个线程的生命周期并不会和Web应用程序保持同步。

也就是说，即使停止了Web应用，这个线程依旧是活跃的。

正是因为这个很隐晦的问题，所以很多有经验的开发者不太赞成在Web应用中私自启动线程。

获取异步线程的返回结果

通过java.util.concurrent包种的相关类，实现异步线程返回结果的获取。代码演示例子如下：

import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class FutureTest {

        public static class TaskRunnable implements Runnable {
                @Override
                public void run() {
                        System.out.println("runnable");
                }
        }

        public static class TaskCallable implements Callable<String> {
                private String s;

                public TaskCallable(String s) {
                        this.s = s;
                }

                @Override
                public String call() throws Exception {
                        System.out.println("callable");
                        return s;
                }
        }

        public static void main(String[] args) {
                ExecutorService es = Executors.newCachedThreadPool();
                for (int i = 0; i < 100; i++) {
                        es.submit(new TaskRunnable());
                        System.out.println(i);
                }

                List<Future<String>> futList = new LinkedList<Future<String>>();
                for (int i = 0; i < 100; i++) {
                        futList.add(es.submit(new TaskCallable(String.valueOf(i))));
                }

                for (Future<String> fut : futList) {
                        try {
                                System.out.println(fut.get());
                        } catch (InterruptedException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                        } catch (ExecutionException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                        }
                }
        }
}