多线程这个名词在计算机理论和软件开发中经常用到，而且在java面向对象程序设计中经常将多线程编程作为高级编程部分，多线程都放到了高级部分，恐怕在校计算机专业的大学生就要悲剧了，要知道很多时候我们将要面对一个知识领域的入门槛的时候，大概也就考试到了，画个重点，勾几个题，刷刷，一本书就噢啦。此情此景相比很多童鞋和我都有相同的感受。

    怎么解释线程是很没有必要的。。百度百科这样。总之我们想一次控制多个任务。

    其实说起线程，讲一个不雅的示例，人在大号的时候，通过都是大号+小号同时进行；就上厕所这件事而言是一个进程，而大号则是开启一个线程处理大号的事务，而小号同时开启一个线程处理小号的事务，互不干涉，当大号和小号都结束时，此时上厕所结束，进程也就结束了。

    还有很多生活中的例子，去饭店吃饭，一个饭店能够在尽量短的时间内为多个客人呈上各式各样的所点的菜，这在他们的后厨和餐厅服务中伴随这不知多少错综复杂的线程关系啊！

   很多时候我们都忽略了学习线程的意义，或者在开发中没能融入生活。说到这想起国美的一个广告：“国美电器，生活又大美”。道理就是这个样子。

  下面写了几个线程的代码块：

   1.在方法中创建一个线程对象，重新线程的run()方法

1. Thread thread1=new Thread(){ 
2.             @Override 
3.             public void run() { 
4.                 while(true){ 
5.                     try { 
6.                         Thread.sleep(500); 
7.                         System.out.println("<Runable-1>\t"+Thread.currentThread().getName()); 
8.                     } catch (InterruptedException e) { 
9.                         e.printStackTrace(); 
10.                     } 
11.                 } 
12.             } 
13.              
14.         }; 
15.         thread1.start(); 

在Thread类中的run()方法查看源代码如下：

1. public void run() { 
2.     if (target != null) { 
3.         target.run(); 
4.     } 
5.     } 

在上面的Thread1对象中我们重新了run()方法。

2.继续查看源代码，Thread类中的init()方法

线程对象一旦创建首先在构造方法中调用了init()方法

1. public Thread() { 
2.     init(null, null, "Thread-" + nextThreadNum(), 0); 
3.     } 

1. private void init(ThreadGroup g, Runnable target, String name, 
2.                       long stackSize) 

上面可以看到init()方法是私有的。继续查看，initl()方法的调用

从init()方法的参数和上图就可以看到在创建Thread对象的时候可以传递Runnable对象，而Runnable又是一个接口，这样以来我们就可以根据实际需要来创建实习Runnable接口的类。

下面是Runnable接口源代码：

1. public 
2. interface Runnable { 
3.     /** 
4.      * When an object implementing interface <code>Runnable</code> is used  
5.      * to create a thread, starting the thread causes the object's  
6.      * <code>run</code> method to be called in that separately executing  
7.      * thread.  
8.      * <p> 
9.      * The general contract of the method <code>run</code> is that it may  
10.      * take any action whatsoever. 
11.      * 
12.      * @see     java.lang.Thread#run() 
13.      */ 
14.     public abstract void run(); 
15. } 

很显然我们只需要实习run()方法就可以了。

1. Thread thread3=new Thread(new Runnable(){ 
2.             @Override 
3.             public void run() { 
4.                 while(true){ 
5.                     try { 
6.                         Thread.sleep(500); 
7.                         System.out.println("<Runable-3>\t"+Thread.currentThread().getName()); 
8.                     } catch (InterruptedException e) { 
9.                         e.printStackTrace(); 
10.                     } 
11.                 } 
12.             } 
13.         }, "Thread3"); 
14.         thread3.start(); 

这样的写法应该是符合面向对象编程的思想，做到了封装性，内部类作为参数

3.为了更为灵活，具体优势很多参见：

首先编写一个类实现Runnable接口：

1. public class SonThread implements Runnable{ 
2.     @Override 
3.     public void run() { 
4.         while(true){ 
5.             try { 
6.                 Thread.sleep(500); 
7.                 System.out.println("<Runable-2>\t"+Thread.currentThread().getName()); 
8.             } catch (InterruptedException e) { 
9.                 e.printStackTrace(); 
10.             } 
11.         } 
12.          
13.     } 
14. } 

然后在使用SonTread类的对象作为Thread类的构造方法的参数，并且在SonThread类中对run()方法实习。

1. SonThread st=new SonThread(); 
2.         Thread thread2=new Thread(st, "<Runable-2>\t"); 
3.         thread2.start(); 

线程的基本创建就这么些，其他都是在这个基础上增加和加强，当然使用多线程往往会伴随这加锁机制，资源共享等方面的编程。