首先可以先搞清楚什么是程序、进程、线程，以及它们之间的关系：

定义：

一 程序只是一组指令的有序集合，它是静态的

二 进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动，是系统进行资源分配和调度的一个独立单位；

三 线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),一个线程可以创建和撤销另一个线程；

进程与线程区别与联系

(1) 划分尺度:线程更小，所以多线程程序并发性更高；

(2) 资源分配：进程是资源分配的基本单位，同一进程内多个线程共享其资源；

(3) 地址空间：进程拥有独立的地址空间，同一进程内多个线程共享其资源；

(4) 处理器调度：线程是处理器调度的基本单位；

(5) 执行：每个线程都有一个程序运行的入口，顺序执行序列和程序的出口，但线程不能单独执行，必须组成进程，一个进程至少有一个主线程。简而言之,一个程序至少有一个进程,一个进程至少有一个线程.

进程和程序区别和联系

（1)程序只是一组指令的有序集合，它本身没有任何运行的含义，它只是一个静态的实体。而进程则不同，它是程序在某个数据集上的执行。进程是一个动态的实体，它有自己的生命周期。反映了一个程序在一定的数据集上运行的全部动态过程。

（2)进程和程序并不是一一对应的，一个程序执行在不同的数据集上就成为不同的进程，可以用进程控制块来唯一地标识每个进程。而这一点正是程序无法做到的，由于程序没有和数据产生直接的联系，既使是执行不同的数据的程序，他们的指令的集合依然是一样的，所以无法唯一地标识出这些运行于不同数据集上的程序。一般来说，一个进程肯定有一个与之对应的程序，而且只有一个。而一个程序有可能没有与之对应的进程(因为它没有执行),也有可能有多个进程与之对应(运行在几个不同的数据集上)。

（3)进程还具有并发性和交往性，这也与程序的封闭性不同。

-------------------------------------------------------------------------------------------

先来转载一个很简单的例子，简单又明了：
先看代码吧：

建一个主函数类：

    public static void main(String[] args) {
        
        thread1 t1 = new thread1();                  
                               //用Thread类的子类创建线程 t1即自定义的线程类
        Thread t2 = new Thread(new thread2());   
                               //用Runnable接口类的对象创建线程，即Java提供的定义方式
        t1.start();        //strat()方法启动线程
        t2.start();
        
    }

建第一个线程类:

public class thread1 extends Thread {

    @Override
    public void run() {

        try {
            Thread.sleep(7000);                         //主线程挂起7秒,之所以加这个方法是为了更好的理解线程．后面我会说的
            System.out.println("one is start......");

        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}
建第二个线程类:

public class thread2 implements Runnable {

    public void run() {

        System.out.println("two is start ...");
    }

}

        这些是原代码，当你运行，结果是two is start ...　然后过7秒one is start....　不知道大家发现没有
主函数应该第一运行thread1.start() 这个类，输出结果是one is start....　但是却没有．而是two is start ...
　　　　　　　　　　thread1.start();//strat()方法启动线程
                                   thread2.start();

可以看出，启动线程的run()方法是通过调用线程的start()方法来实现的(见上例中主类)，调用start()方法启动线程的run()方法不同于一般的调用方法，调用一般方法时，必须等到一般方法执行完毕才能够返回start()方法，而启动线程的run()方法后，start()告诉系统该线程准备就绪可以启动run()方法后，就返回start()方法执行调用start()方法语句下面的语句，这时run()方法可能还在运行，这样，线程的启动和运行并行进行，实现了多任务操作。 
所以大家明白了吧，用了线程了，他们之间是互不影响的．thread1.start()　还没有结束，对thread2.start()没有影响　现在也明白我在thread1类中加Thread.sleep(7000)的意义了吧
就是为了更好的理解线程！
      本篇文章来源于 :刘志猛博客 原文链接：http://www.liuzm.com/article/java/9128b.htm

----------------------下面来稍微复杂一点点的：

编写具有多线程能力的程序经常会用到的方法有： 

　　run(), start(), wait(), notify(), notifyAll(), sleep(), yield(), join() 

　　还有一个重要的关键字：synchronized 

　　本文将对以上内容进行讲解。 

　　一：run() 和start() 

　　示例1： 

public class ThreadTest extends Thread { 
public void run() { 
for (int i = 0; i < 10; i++) { 
System.out.print(" " + i); 
} 
} 

public static void main(String[] args) { 
new ThreadTest().start(); 
new ThreadTest().start(); 
} 
} 

　　这是个简单的多线程程序。run() 和start() 是大家都很熟悉的两个方法。把希望并行处理的代码都放在run() 中；stat() 用于自动调用run()， 
这是JAVA的内在机制规定的。并且run() 的访问控制符必须是public，返回值必须是void（这种说法不准确，run() 没有返回值），run() 
不带参数。 

　　这些规定想必大家都早已知道了，但你是否清楚为什么run方法必须声明成这样的形式？这涉及到JAVA的方法覆盖和重载的规定。这些内容很重要， 
请读者参考相关资料。 

　　二：关键字synchronized 

　　有了synchronized关键字，多线程程序的运行结果将变得可以控制。synchronized关键字用于保护共享数据。请大家注意 "共享数据"， 
你一定要分清哪些数据是共享数据，JAVA是面向对象的程序设计语言，所以初学者在编写多线程程序时，容易分不清哪些数据是共享数据。请看下面的例子： 

　　示例2： 

public class ThreadTest implements Runnable { 

public synchronized void run() { 
for (int i = 0; i < 10; i++) { 
System.out.print(" " + i); 
} 
} 

public static void main(String[] args) { 
Runnable r1 = new ThreadTest(); 
Runnable r2 = new ThreadTest(); 
Thread t1 = new Thread(r1); 
Thread t2 = new Thread(r2); 
t1.start(); 
t2.start(); 
} 
} 

　　在这个程序中，run() 被加上了synchronized关键字。在main方法中创建了两个线程。你可能会认为此程序的运行结果一定为：0123456789 
0123456789。但你错了！这个程序中synchronized关键字保护的不是共享数据（ 
其实在这个程序中synchronized关键字没有起到任何作用，此程序的运行结果是不可预先确定的）。这个程序中的t1, t2是两个对象（r1, 
r2）的线程。JAVA是面向对象的程序设计语言，不同的对象的数据是不同的，r1, 
r2有各自的run() 方法，而synchronized使同一个对象的多个线程， 
在某个时刻只有其中的一个线程可以访问这个对象的synchronized数据。每个对象都有一个 "锁标志"， 
当这个对象的一个线程访问这个对象的某个synchronized数据时，这个对象的所有被synchronized修饰的数据将被上锁（因为 "锁标志" 
被当前线程拿走了），只有当前线程访问完它要访问的synchronized数据时，当前线程才会释放 "锁标志"， 
这样同一个对象的其它线程才有机会访问synchronized数据。 

　　示例3： 

public class ThreadTest implements Runnable { 
public synchronized void run() { 
for (int i = 0; i < 10; i++) { 
System.out.print(" " + i); 
} 
} 

public static void main(String[] args) { 
Runnable r = new ThreadTest(); 
Thread t1 = new Thread(r); 
Thread t2 = new Thread(r); 
t1.start(); 

t2.start(); 
} 
} 

　　如果你运行1000次这个程序，它的输出结果也一定每次都是：01234567890123456789。因为这里的synchronized保护的是共享数据。 
t1, 
t2是同一个对象（r）的两个线程，当其中的一个线程（例如：t1）开始执行run() 方法时，由于run() 受synchronized保护，所以同一个对象的其他线程（ 
t2）无法访问synchronized方法（run方法）。只有当t1执行完后t2才有机会执行。 

　　示例4： 

public class ThreadTest implements Runnable { 
public void run() { 
synchronized (this) { 
for (int i = 0; i < 10; i++) { 
System.out.print(" " + i); 
} 
} 
} 

public static void main(String[] args) { 
Runnable r = new ThreadTest(); 
Thread t1 = new Thread(r); 
Thread t2 = new Thread(r); 
t1.start(); 
t2.start(); 
} 
} 

　　这个程序与示例3的运行结果一样。在可能的情况下，应该把保护范围缩到最小，可以用示例4的形式，this代表 "这个对象"。没有必要把整个run() 保护起来， 
run() 中的代码只有一个for循环，所以只要保护for循环就可以了。 

　　示例5： 

public class ThreadTest implements Runnable { 
public void run() { 
for (int k = 0; k < 5; k++) { 
System.out.println(Thread.currentThread().getName() 
+ " : for loop : " + k); 

} 
synchronized (this) { 
for (int k = 0; k < 5; k++) { 
System.out.println(Thread.currentThread().getName() 
+ " : synchronized for loop : " + k); 
} 
} 
} 

public static void main(String[] args) { 
Runnable r = new ThreadTest(); 
Thread t1 = new Thread(r, "t1_name"); 
Thread t2 = new Thread(r, "t2_name"); 
t1.start(); 
t2.start(); 
} 
} 

运行结果：t1_name : for loop : 0 
t1_name : for loop : 1 
t1_name : for loop : 2 
t2_name : for loop : 0 
t1_name : for loop : 3 
t2_name : for loop : 1 
t1_name : for loop : 4 
t2_name : for loop : 2 
t1_name : synchronized for loop : 0 
t2_name : for loop : 3 
t1_name : synchronized for loop : 1 
t2_name : for loop : 4 
t1_name : synchronized for loop : 2 
t1_name : synchronized for loop : 3 
t1_name : synchronized for loop : 4 
t2_name : synchronized for loop : 0 
t2_name : synchronized for loop : 1 
t2_name : synchronized for loop : 2 
t2_name : synchronized for loop : 3 
t2_name : synchronized for loop : 4 

　　第一个for循环没有受synchronized保护。对于第一个for循环，t1, 
t2可以同时访问。运行结果表明t1执行到了k = 2时，t2开始执行了。t1首先执行完了第一个for循环，此时还没有执行完第一个for循环（ 
t2刚执行到k = 2）。t1开始执行第二个for循环，当t1的第二个for循环执行到k = 1时，t2的第一个for循环执行完了。 
t2想开始执行第二个for循环，但由于t1首先执行了第二个for循环，这个对象的锁标志自然在t1手中（ 
synchronized方法的执行权也就落到了t1手中），在t1没执行完第二个for循环的时候，它是不会释放锁标志的。 
所以t2必须等到t1执行完第二个for循环后，它才可以执行第二个for循环 

三：sleep() 

　　示例6： 

public class ThreadTest implements Runnable { 
public void run() { 
for (int k = 0; k < 5; k++) { 
if (k == 2) { 
try { 
Thread.currentThread().sleep(5000); 
} 
catch (Exception e) {} 
} 
System.out.print(" " + k); 
} 
} 

public static void main(String[] args) { 
Runnable r = new ThreadTest(); 
Thread t = new Thread(r); 
t.start(); 
} 
} 

　　sleep方法会使当前的线程暂停执行一定时间（给其它线程运行机会）。读者可以运行示例6，看看结果就明白了。sleep方法会抛出异常，必须提供捕获代码。 

　　示例7： 

public class ThreadTest implements Runnable { 
public void run() { 

for (int k = 0; k < 5; k++) { 
if (k == 2) { 
try { 
Thread.currentThread().sleep(5000); 
} 
catch (Exception e) {} 
} 
System.out.println(Thread.currentThread().getName() 
+ " : " + k); 
} 
} 

public static void main(String[] args) { 
Runnable r = new ThreadTest(); 
Thread t1 = new Thread(r, "t1_name"); 
Thread t2 = new Thread(r, "t2_name"); 
t1.setPriority(Thread.MAX_PRIORITY); 
t2.setPriority(Thread.MIN_PRIORITY); 
t1.start(); 
t2.start(); 
} 
} 

　　t1被设置了最高的优先级，t2被设置了最低的优先级。t1不执行完，t2就没有机会执行。但由于t1在执行的中途休息了5秒中，这使得t2就有机会执行了。 
读者可以运行这个程序试试看。 

　　示例8： 

public class ThreadTest implements Runnable { 
public synchronized void run() { 
for (int k = 0; k < 5; k++) { 
if (k == 2) { 
try { 
Thread.currentThread().sleep(5000); 
} 
catch (Exception e) {} 

} 
System.out.println(Thread.currentThread().getName() 
+ " : " + k); 
} 
} 

public static void main(String[] args) { 
Runnable r = new ThreadTest(); 
Thread t1 = new Thread(r, "t1_name"); 
Thread t2 = new Thread(r, "t2_name"); 
t1.start(); 
t2.start(); 
} 
} 

　　请读者首先运行示例8程序，从运行结果上看：一个线程在sleep的时候，并不会释放这个对象的锁标志。 

　　四：join() 

　　示例9： 

public class ThreadTest implements Runnable { 
public static int a = 0; 
public void run() { 
for (int k = 0; k < 5; k++) { 
a = a + 1; 
} 
} 

public static void main(String[] args) { 
Runnable r = new ThreadTest(); 
Thread t = new Thread(r); 
t.start(); 
System.out.println(a); 
} 
} 

　　请问程序的输出结果是5吗？答案是：有可能。其实你很难遇到输出5的时候，通常情况下都不是5。这里不讲解为什么输出结果不是5，我要讲的是： 
怎样才能让输出结果为5！其实很简单，join() 方法提供了这种功能。join() 方法，它能够使调用该方法的线程在此之前执行完毕。 

　　把示例9的main() 方法该成如下这样： 

public static void main(String[] args) throws Exception { 
Runnable r = new ThreadTest(); 
Thread t = new Thread(r); 
t.start(); 
t.join(); 
System.out.println(a); 
} 

　　这时，输出结果肯定是5！join() 方法会抛出异常，应该提供捕获代码。或留给JDK捕获。 

　　示例10： 

public class ThreadTest implements Runnable { 
public void run() { 
for (int k = 0; k < 10; k++) { 
System.out.print(" " + k); 
} 
} 

public static void main(String[] args) throws Exception { 
Runnable r = new ThreadTest(); 
Thread t1 = new Thread(r); 
Thread t2 = new Thread(r); 
t1.start(); 
t1.join(); 
t2.start(); 
} 
} 

　　运行这个程序，看看结果是否与示例3一样 

五：yield() 

　　yield() 方法与sleep() 方法相似，只是它不能由用户指定线程暂停多长时间。按照SUN的说法： 
sleep方法可以使低优先级的线程得到执行的机会，当然也可以让同优先级和高优先级的线程有执行的机会。而yield() 
方法只能使同优先级的线程有执行的机会。 

　　示例11： 

public class ThreadTest implements Runnable { 
public void run() { 
8 
for (int k = 0; k < 10; k++) { 
if (k == 5 && Thread.currentThread().getName().equals("t1")) { 
Thread.yield(); 
} 
System.out.println(Thread.currentThread().getName() 
+ " : " + k); 
} 
} 

public static void main(String[] args) { 
Runnable r = new ThreadTest(); 
Thread t1 = new Thread(r, "t1"); 
Thread t2 = new Thread(r, "t2"); 
t1.setPriority(Thread.MAX_PRIORITY); 
t2.setPriority(Thread.MIN_PRIORITY); 
t1.start(); 
t2.start(); 
} 
} 

输出结果： 
t1 : 0 
t1 : 1 
t1 : 2 
t1 : 3 
t1 : 4 
t1 : 5 
t1 : 6 
t1 : 7 
t1 : 8 
t1 : 9 
t2 : 0 
t2 : 1 
t2 : 2 
t2 : 3 
t2 : 4 
t2 : 5 
t2 : 6 
t2 : 7 
t2 : 8 
t2 : 9 

　　多次运行这个程序，输出也是一样。这说明：yield() 方法不会使不同优先级的线程有执行的机会。 

　　六：wait(), notify(), notifyAll() 

　　首先说明：wait(), notify(), 
notifyAll() 这些方法由java.lang.Object类提供，而上面讲到的方法都是由java.lang.Thread类提供（ 
Thread类实现了Runnable接口）。 

　　wait(), notify(), 
notifyAll() 这三个方法用于协调多个线程对共享数据的存取，所以必须在synchronized语句块内使用这三个方法。先看下面了例子： 

　　示例12： 

public class ThreadTest implements Runnable { 
public static int shareVar = 0; 
public synchronized void run() { 
if (shareVar == 0) { 
for (int i = 0; i < 10; i++) { 
shareVar++; 
if (shareVar == 5) { 
try { 
this.wait(); 
} 
catch (Exception e) {} 
} 
} 
} 
if (shareVar != 0) { 
System.out.print(Thread.currentThread().getName()); 
System.out.println(" shareVar = " + shareVar); 
this.notify(); 
} 
} 

public static void main(String[] args) { 
Runnable r = new ThreadTest(); 
Thread t1 = new Thread(r, "t1"); 
10 
Thread t2 = new Thread(r, "t2"); 
t1.start(); 
t2.start(); 
} 
} 

运行结果： 
t2 shareVar = 5 
t1 shareVar = 10 

　　t1线程最先执行。由于初始状态下shareVar为0，t1将使shareVar连续加1，当shareVar的值为5时，t1调用wait() 方法， 
t1将处于休息状态，同时释放锁标志。这时t2得到了锁标志开始执行，shareVar的值已经变为5，所以t2直接输出shareVar的值， 
然后再调用notify() 方法唤醒t1。t1接着上次休息前的进度继续执行，把shareVar的值一直加到10，由于此刻shareVar的值不为0， 
所以t1将输出此刻shareVar的值，然后再调用notify() 方法，由于此刻已经没有等待锁标志的线程，所以此调用语句不起任何作用。 

　　这个程序简单的示范了wait(), notify() 的用法，读者还需要在实践中继续摸索。 

　　七：关于线程的补充 

　　编写一个具有多线程能力的程序可以继承Thread类，也可以实现Runnable接口。在这两个方法中如何选择呢？从面向对象的角度考虑， 
作者建议你实现Runnable接口。有时你也必须实现Runnable接口，例如当你编写具有多线程能力的小应用程序的时候。 

　　线程的调度：NewRunningRunnableOtherwise BlockedDeadBlocked in object`sit() 
poolBlocked in object`slock poolnotify() Schedulercompletesrun() start() 
sleep() or join() sleep() timeout or thread join() s or interupt() 
Lockavailablesynchronized() Thread states 

　　terupt() 一个Thread对象在它的生命周期中会处于各种不同的状态，上图形象地说明了这点。wa in 

　　调用start() 方法使线程处于可运行状态，这意味着它可以由JVM调度并执行。这并不意味着线程就会立即运行。 

　　实际上，程序中的多个线程并不是同时执行的。除非线程正在真正的多CPU计算机系统上执行，否则线程使用单CPU必须轮流执行。但是，由于这发生的很快， 
我们常常认为这些线程是同时执行的。 

　　JAVA运行时系统的计划调度程序是抢占性的。如果计划调度程序正在运行一个线程并且来了另一个优先级更高的线程， 
那么当前正在执行的线程就被暂时终止而让更高优先级的线程执行。 

　　JAVA计划调度程序不会为与当前线程具有同样优先级的另一个线程去抢占当前的线程。但是，尽管计划调度程序本身没有时间片（ 
即它没有给相同优先级的线程以执行用的时间片），但以Thread类为基础的线程的系统实现可能会支持时间片分配。这依赖具体的操作系统， 
Windows与UNIX在这个问题上的支持不会完全一样。 

　　由于你不能肯定小应用程序将运行在什么操作系统上，因此你不应该编写出依赖时间片分配的程序。就是说， 
应该使用yield方法以允许相同优先级的线程有机会执行而不是希望每一个线程都自动得到一段CPU时间片。 

　　Thread类提供给你与系统无关的处理线程的机制。但是，线程的实际实现取决于JAVA运行所在的操作系统。因此， 
线程化的程序确实是利用了支持线程的操作系统。 

　　当创建线程时，可以赋予它优先级。它的优先级越高，它就越能影响运行系统。 
JAVA运行系统使用一个负责在所有执行JAVA程序内运行所有存在的计划调度程序。
该计划调度程序实际上使用一个固定优先级的算法来保证每个程序中的最高优先级的线程得到CPU--允许最高优先级的线程在其它线程之前执行。 

　　对于在一个程序中有几个相同优先级的线程等待执行的情况，该计划调度程序循环地选择它们，当进行下一次选择时选择前面没有执行的线程， 
具有相同优先级的所有的线程都受到平等的对待。较低优先级的线程在较高优先级的线程已经死亡或者进入不可执行状态之后才能执行。 

　　继续讨论wait(), notify(), notifyAll()： 

　　当线程执行了对一个特定对象的wait() 调用时，那个线程被放到与那个对象相关的等待池中。此外，调用wait() 的线程自动释放对象的锁标志。 

　　可以调用不同的wait()：wait() 或wait(long timeout) 

　　对一个特定对象执行notify() 调用时，将从对象的等待池中移走一个任意的线程，并放到锁标志等待池中，那里的线程一直在等待， 
直到可以获得对象的锁标志。notifyAll() 方法将从对象等待池中移走所有等待那个对象的线程并放到锁标志等待池中。 
只有锁标志等待池中的线程能获取对象的锁标志，锁标志允许线程从上次因调用wait() 而中断的地方开始继续运行。 

　　在许多实现了wait() / notify() 机制的系统中，醒来的线程必定是那个等待时间最长的线程。然而，在Java技术中，并不保证这点。 

　　注意，不管是否有线程在等待，都可以调用notify()。如果对一个对象调用notify() 方法，而在这个对象的锁标志等待池中并没有线程， 
那么notify() 调用将不起任何作用。 

　　在JAVA中，多线程是一个神奇的主题。之所以说它 "神奇"，是因为多线程程序的运行结果不可预测，但我们又可以通过某些方法控制多线程程序的执行。 
要想灵活使用多线程，读者还需要大量实践。 
//　　另外，从JDK 1.2开始，SUN就不建议使用resume(), stop(), suspend() 了

-----------------------------------------------------------------

最后贴一段简单的代码自己看着玩：

import java.io.*;

//多线程编程 
public class MultiThread   
{ 
public static void main(String args[]) 
{ 
System.out.println("我是主线程!"); 
//下面创建线程实例thread1 
ThreadUseExtends thread1=new ThreadUseExtends(); 
//创建thread2时以实现了Runnable接口的THhreadUseRunnable类实例为参数 
Thread thread2=new Thread(new ThreadUseRunnable(),"SecondThread"); 
thread1.start();//启动线程thread1使之处于就绪状态 
//thread1.setPriority(6);//设置thread1的优先级为6 
//优先级将决定cpu空出时，处于就绪状态的线程谁先占领cpu开始运行 
//优先级范围1到10,MIN_PRIORITY,MAX_PRIORITY,NORM_PAIORITY 
//新线程继承创建她的父线程优先级,父线程通常有普通优先级即5NORM_PRIORITY 
System.out.println("主线程将挂起7秒!"); 
try 
{ 
Thread.sleep(7000);//主线程挂起7秒 
} 
catch (InterruptedException e) 
{ 
return; 
} 
System.out.println("又回到了主线程!"); 
if(thread1.isAlive()) 
{   
thread1.stop();//如果thread1还存在则杀掉他 
System.out.println("thread1休眠过长,主线程杀掉了thread1!"); 
} 
else 
System.out.println("主线程没发现thread1,thread1已醒顺序执行结束了!"); 
thread2.start();//启动thread2 
System.out.println("主线程又将挂起7秒!"); 
try 
{ 
Thread.sleep(7000);//主线程挂起7秒 
} 
catch (InterruptedException e) 
{ 
return; 
} 
System.out.println("又回到了主线程!"); 
if(thread2.isAlive()) 
{   
thread2.stop();//如果thread2还存在则杀掉他 
System.out.println("thread2休眠过长，主线程杀掉了thread2!"); 
} 
else 
System.out.println("主线程没发现thread2,thread2已醒顺序执行结束了!"); 
System.out.println("程序结束按任意键继续!"); 
try 
{ 
System.in.read(); 
} 
catch (IOException e) 
{ 
System.out.println(e.toString()); 
}

}//main 
}//MultiThread

class ThreadUseExtends extends Thread 
//通过继承Thread类,并实现它的抽象方法run() 
//适当时候创建这一Thread子类的实例来实现多线程机制 
//一个线程启动后（也即进入就绪状态）一旦获得CPU将自动调用它的run()方法 
{

ThreadUseExtends(){}//构造函数 
public void run() 
{ 
System.out.println("我是Thread子类的线程实例!"); 
System.out.println("我将挂起10秒!"); 
System.out.println("回到主线程,请稍等,刚才主线程挂起可能还没醒过来！"); 
try 
{ 
sleep(10000);//挂起5秒 
} 
catch (InterruptedException e) 
{ 
return; 
} 
//如果该run()方法顺序执行完了,线程将自动结束,而不会被主线程杀掉 
//但如果休眠时间过长,则线程还存活,可能被stop()杀掉 
} 
}

class ThreadUseRunnable implements Runnable 
//通过实现Runnable接口中的run()方法,再以这个实现了run()方法的类 
//为参数创建Thread的线程实例 
{ 
//Thread thread2=new Thread(this); 
//以这个实现了Runnable接口中run()方法的类为参数创建Thread类的线程实例 
ThreadUseRunnable(){}//构造函数 
public void run() 
{ 
System.out.println("我是Thread类的线程实例并以实现了Runnable接口的类为参数!"); 
System.out.println("我将挂起1秒!"); 
System.out.println("回到主线程,请稍等 jn0-120 e20-040 ,刚才主线程挂起可能还没醒过来！"); 
try 
{ 
Thread.sleep(1000);//挂起5秒 
} 
catch (InterruptedException e) 
{ 
return; 
} 
//如果该run()方法顺序执行完了,线程将自动结束,而不会被主线程杀掉 
//但如果休眠时间过长,则线程还存活,可能被stop()杀掉 
}

} 
//该程序可做的修改如改休眠时间或优先级setPriority()
--------------------------------------

最后，还在百度文库上看了一篇，写得也通俗易懂，大家可以借鉴一下：

http://wenku.baidu.com/view/51923164783e0912a2162abe.html

或者大家使用google搜索一下，很多案例的。