一、Thread.start()与Thread.run()的区别
　　通过调用Thread类的start()方法来启动一个线程，这时此线程是处于绪状态，并没有运行。然后通过此Thread类调用方法run()来完成其运行操作的，这里方法run()称为线程体，它包含了要执行的这个线程的内容，Run方法运行结束，此线程终止，而CPU再运行其它线程。
　　而如果直接用Run方法，这只是调用一个方法而已，程序中依然只有“主线程”这一个线程，并没有开辟新线程，其程序执行路径还是只有一条，这样没有达到写线程的目的。
　　测试代码如下
　　public class MyThread implements Runnable {
　　public void run() {
　　System.err.println(Thread.currentThread().getName());
　　}
　　public static void main(String[] args) {
　　MyThread thread = new MyThread();
　　Thread t1 = new Thread(thread， "Thread-1");
　　Thread t2 = new Thread(thread， "Thread-2");
　　t1.run();
　　t2.run();
　　}
　　}
　　输出结果为
　　>>当前进程为：main
　　>>当前进程为：main
　　改为用start方法：
　　package thread;
　　public class MyThread implements Runnable {
　　public void run() {
　　System.err.println(">>当前进程为："+Thread.currentThread().getName());
　　}
　　public static void main(String[] args) {
　　MyThread thread = new MyThread();
　　Thread t1 = new Thread(thread， "Thread-1");
　　Thread t2 = new Thread(thread， "Thread-2");
　　t1.start();
　　t2.start();
　　}
　　}
　　结果为：
　　>>当前进程为：Thread-1
　　>>当前进程为：Thread-2
　　二、ThreadLocal类详解
　　ThreadLocal很容易让人望文生义，想当然地认为是一个“本地线程”。其实，ThreadLocal并不是一个Thread，而是Thread的局部变量，也许把它命名为ThreadLocalVariable更容易让人理解一些。当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。
　　下面是线程局部变量(ThreadLocal variables)的关键点：
　　一个线程局部变量(ThreadLocal variables)为每个线程方便地提供了一个单独的变量。在多个线程操作该变量时候能够互不影响，因为每个线程操作的实际上是改变量的副本。ThreadLocal实例通常作为静态的私有的(private static)字段出现在一个类中，这个类用来关联线程。当多个线程访问ThreadLocal实例时，每个线程维护ThreadLocal提供的独立的变量副本。
　　下面是测试代码，用于测试：作用于一个对象上面的三个线程来操作同一个ThreadLoacl对象（integer 类型），看是否会出现脏读等现象：
　　public class Test implements Runnable {
　　private static ThreadLocal<Integer> num = new ThreadLocal<Integer>();
　　public void run() {
　　num.set(0);
　　for (int i = 0; i < 3; i++) {
　　num.set(num.get() + 1);
　　System.out.println(Thread.currentThread().getName() + ":num="
　　+ num.get());
　　}
　　}
　　public static void main(String[] args) {
　　Test test = new Test();
　　Thread t1 = new Thread(test， "Thread-1");
　　Thread t2 = new Thread(test， "Thread-2");
　　Thread t3 = new Thread(test， "Thread-3");
　　t1.start();
　　t2.start();
　　t3.start();
　　}
　　}
　　运行结果如下：
　　Thread-3:num=1
　　Thread-2:num=1
　　Thread-1:num=1
　　Thread-2:num=2
　　Thread-3:num=2
　　Thread-2:num=3
　　Thread-1:num=2
　　Thread-1:num=3
　　Thread-3:num=3
　　从上面可以看出，完全没有出现脏读等的现象，因此ThreadLocal线程安全。
　　常用的使用：当DAO类作为一个单例类时，数据库链接(connection)被每一个线程独立的维护，互不影响。
　　可以用来控制session的创建和使用，如下ThreadLocal<Session> session =     new ThreadLocal<Session>();
　　ThreadLoacal与同步机制的比较：
　　1、在同步机制中，通过对象的锁机制保证同一时间只有一个线程访问变量。这时该变量是多个线程共享的，使用同步机制要求程序慎密地分析什么时候对变量进行读写，什么时候需要锁定某个对象，什么时候释放对象锁等繁杂的问题，程序设计和编写难度相对较大。
　　2、而ThreadLocal则从另一个角度来解决多线程的并发访问。ThreadLocal会为每一个线程提供一个独立的变量副本，从而隔离了多个线程对数据的访问冲突。因为每一个线程都拥有自己的变量副本，从而也没有必要对该变量进行同步了。ThreadLocal提供了线程安全的共享对象，在编写多线程代码时，可以把不安全的变量封装进ThreadLocal。
　　3、概括起来说，对于多线程资源共享的问题，同步机制采用了“以时间换空间”的方式，而ThreadLocal采用了“以空间换时间”的方式。前者仅提供一份变量，让不同的线程排队访问，而后者为每一个线程都提供了一份变量，因此可以同时访问而互不影响。
　　三、InvalidMonitorStateException异常
　　调用wait()/notify()/notifyAll()中的任何一个方法时，如果当前线程没有获得该对象的锁，那么会抛出IllegalMonitorStateException的异常(也是说程序在没有执行对象的任何同步块或者同步方法时，仍然尝试调用wait()/notify()/notifyAll()时)。由于该异常是RuntimeExcpetion的子类，所以该异常不一定要捕获(尽管你可以捕获只要你愿意).作为RuntimeException，此类异常不会在wait()，notify()，notifyAll()的方法签名提及。
　　如下代码，划线的部分会发生该异常，因为没有对该对象执行同步操作。
　　public class Common implements Runnable {
　　public synchronized void method1() throws InterruptedException {
　　Thread.sleep(1000);
　　System.out.println("Method 1 called");
　　Thread.sleep(1000);
　　System.out.println("Method 1 done");
　　}
　　public synchronized void method2() throws InterruptedException {
　　Thread.sleep(1000);
　　System.err.println("Method 2 called");
　　Thread.sleep(1000);
　　System.err.println("Method 2 done");
　　}
　　public void run() {
　　System.out.println("Running " + Thread.currentThread().getName());
　　try {
　　if (Thread.currentThread().getName().equals("Thread-1")) {
　　this.wait(1000);
　　method1();
　　} else {
　　method2();
　　notifyAll();
　　}
　　} catch (Exception e) {
　　e.printStackTrace();
　　}
　　}
　　public static void main(String[] args) throws InterruptedException {
　　Common c = new Common();
　　Thread t1 = new Thread(c， "Thread-1");
　　Thread t2 = new Thread(c， "Thread-2");
　　t1.start();
　　t2.start();
　　}
　　}
　　改为一下代码，划线部分：
　　public class Common implements Runnable {
　　public synchronized void method1() throws InterruptedException {
　　Thread.sleep(1000);
　　System.out.println("Method 1 called");
　　Thread.sleep(1000);
　　System.out.println("Method 1 done");
　　}
　　public synchronized void method2() throws InterruptedException {
　　Thread.sleep(1000);
　　System.err.println("Method 2 called");
　　Thread.sleep(1000);
　　System.err.println("Method 2 done");
　　}
　　public void run() {
　　System.out.println("Running " + Thread.currentThread().getName());
　　try {
　　if (Thread.currentThread().getName().equals("Thread-1")) {
　　synchronized(this){
　　this.wait(1000);
　　}
　　method1();
　　} else {
　　method2();
　　synchronized (this) {
　　notifyAll();
　　}
　　}
　　} catch (Exception e) {
　　e.printStackTrace();
　　}
　　}
　　public static void main(String[] args) throws InterruptedException {
　　Common c = new Common();
　　Thread t1 = new Thread(c， "Thread-1");
　　Thread t2 = new Thread(c， "Thread-2");
　　t1.start();
　　t2.start();
　　}
　　}