线程，是指正在执行的一个指点令序列。在java平台上是指从一个线程对象的start()开始。运行run方法体中的那一段相对独立的过程。

线程的并发与并行

在过去的电脑都已单CPU作为主要的处理方式，无论是PC或者是服务器都是如此。系统调用某一个时刻只能有一个线程运行。当然这当中采用了比较多的策略来做时间片轮询。通过不断的调度切换来运行线程运行，而这种方式就叫做并发（concurrent）。

随着工艺水平的逐渐提升，CPU的技术也在不断增进。因此在如今多个CPU已经不是什么特别的，而大家常常以SMP的方式来形容多个CPU来处理两个或者两个以上的线程运行方式就称为并行（parallel）。

JAVA线程对象

                                          继承Thread，实现start()方法

要实现线程运行，JAVA中有两种方式：

                                      实现Runnable，然后再传递给Thread实例

注意：线程对象和线程是两个截然不同的概念。

线程对象是JVM产生的一个普通的Object子类

线程是CPU分配给这个对象的一个运行过程

public class Test {

 public static void main(String[] args) throws Exception{

    MyThread mt = new MyThread();

    mt.start();

    mt.join();

    Thread.sleep(3000);

    mt.start();

 }

}

当线程对象mt运行完成后,我们让主线程休息一下，然后我们再次在这个线程对象上启动线程.结果我们看到：

Exception in thread "main" java.lang.IllegalThreadStateException

根本原因是在以下源代码中找出：

public synchronized void start() {

        if (started)
            throw new IllegalThreadStateException();

        started = true;

       group.add(this);

        start0();

 }

一个Thread的实例一旦调用start()方法，这个实例的started标记就标记为true，事实中不管这个线程后来有没有执行到底，只要调用了一次start()就再也没有机会运行了，这意味着：

【通过Thread实例的start()，一个Thread的实例只能产生一个线程】

interrupt()方法

当一个线程对象调用interrupt()方法，它对应的线程并没有被中断，只是改变了它的中断状态。使当前线程的状态变以中断状态，如果没有其它影响，线程还会自己继续执行。只有当线程执行到sleep，wait，join等方法时，或者自己检查中断状态而抛出异常的情况下，线程才会抛出异常。

join()方法

join()方法，正如第一节所言，在一个线程对象上调用join方法，是当前线程等待这个线程对象对应的线程结束

例如：有两个工作，工作A要耗时10秒钟，工作B要耗时10秒或更多。我们在程序中先生成一个线程去做工作B，然后做工作A。

        new B().start();//做工作B

A();//做工作A

工作A完成后，下面要等待工作B的结果来进行处理。如果工作B还没有完成我就不能进行下面的工作C，所以：

B b = new B();

b.start();//做工作B

A();//做工作A

b.join();//等工作B完成.

C();//继续工作C

原则：【join是测试其它工作状态的唯一正确方法】

yield()方法

yield()方法也是类方法，只在当前线程上调用，理由同上，它主是让当前线程放弃本次分配到的时间片，调用这个方法不会提高任何效率，只是降低了CPU的总周期上面介绍的线程一些方法，基于(基础篇)而言只能简单提及。以后具体应用中我会结合实例详细论述。

原则：【不是非常必要的情况下，没有理由调用它】

wait()、notify()/notityAll()方法

首先明确一点他们的属于普通对象方法，并非是线程对象方法；其次它们只能在同步方法中调用。线程要想调用一个对象的wait()方法就要先获得该对象的监视锁,而一旦调用wait()后又立即释放该锁。

线程的互斥控制

多个线程同时操作某一对象时，一个线程对该对象的操作可能会改变其状态，而该状态会影响另一线程对该对象的真正结果。

synchornized关键字

把一个单元声明为synchornized,就可以让在同一时间只有一个线程操作该方法。作为记忆可以把synchronized看作是一个锁。但是我们要理解锁是被动的，还是主动的呢？换而言之它到底锁什么了？锁谁了？

例如：

synchronized(obj){

                 //todo…

}

如果代码运行到此处，synchronized首先获取obj参数对象的锁，若没有获取线程只能等待，如果多个线程运行到这只能有一个线程获取obj的锁，然后再执行{}中的代码。因此obj作用范围不同，控制程序也不同。

如果一个方法声明为synchornized的，则等同于把在为个方法上调用synchornized(this)。

如果一个静态方法被声明为synchornized，则等同于把在为个方法上调用synchornized(类.class)

真正的停止线程

要让一个线程得到真正意义的停止，需要了解当前的线程在干什么，如果线程当前没有做什么，那立刻让对方退出，当然是没有任何问题，但是如果对方正在手头赶工，那就必须让他停止，然后收拾残局。因此，首先需要了解步骤：

1.     正常运行；

2.       处理结束前的工作,也就是准备结束；

3.       结束退出。