java中有几种方法可以实现一个线程？

有两种实现方法，分别是继承Thread类与实现Runnable接口

java5以前，有如下两种：

有两种实现方法，分别使用new Thread()和new Thread(runnable)形式，第一种直接调用thread的run方法，所以，我们往往使用Thread子类，即new SubThread()。第二种调用runnable的run方法。

第一种：

new Thread(){}.start();这表示调用Thread子类对象的run方法，new Thread(){}表示一个Thread的匿名子类的实例对象，子类加上run方法后的代码如下：

new Thread(){

   public void run(){

   }

}.start();



第二种：

new Thread(new Runnable(){}).start();这表示调用Thread对象接受的Runnable对象的run方法，new Runnable(){}表示一个Runnable的匿名子类的实例对象,runnable的子类加上run方法后的代码如下：

new Thread(new Runnable(){

               public void run(){

               }   

        }

   ).start();

从java5开始，还有如下一些线程池创建多线程的方式：

ExecutorService pool = Executors.newFixedThreadPool(3)

for(int i=0;i<10;i++)

{

pool.execute(new Runable(){public void run(){}});

}

Executors.newCachedThreadPool().execute(new Runable(){public void run(){}});

Executors.newSingleThreadExecutor().execute(new Runable(){public void run(){}});

有两种实现方法，分别使用new Thread()和new Thread(runnable)形式，第一种直接调用thread的run方法，所以，我们往往使用Thread子类，即new SubThread()。第二种调用runnable的run方法。

Java中实现多线程有两种方法：一种是继承Thread类；另一种是实现Runnable接口。
1.线程类继承Thread类的语法：
(public) class 类名 extends Thread{
        public void run(){//这里写线程的内容}}
2.线程类实现java.lang.Runnable类的语法：
(public) class 类名 implements Runnable{
        public void run(){//这里写线程的内容}}
推荐使用第二种方法。

JAVA 的多线程特性是它的一大优点。多线程是相对单线程而言的，单线程是指任何时候只能有一个程序在运行，其他程序必须等待。而有了多线程这个特性后，JAVA 可以支持多个程序并发执行。当你要写一个能同时执行多个功能的程序时，就需要用到JAVA 的多线程功能。JAVA 的多线程功能被封装在线程类中。

在java中要想实现多线程，有两种手段，一种是继续Thread类，另外一种是实现Runable接口

1. 使用继承 Thread 类的方法实现多线程

1.   package com.zsc.everyday;  
   
2.     //使用继承 Thread 类的方法实现多线程  
   
3.     public class FirstThread extends Thread {  
   
4.         private int i  ;  
   
5.         //重写 run 方法，run方法中的方法是现成的执行方法  
   
6.         public void run(){  
   
7.             for(;i<5;i++){  
   
8.                 // getName() 函数是获取线程名称  
   
9.                 System.out.println(getName()+"、"+i);  
   
10.             }  
    
11.         }  
    
12.         public static void main(String[] args) {  
    
13.             for(int i =0 ;i<5;i++){  
    
14.                 System.out.println(Thread.currentThread().getName()+"、"+i);  
    
15.                 if(i==2){  
    
16.                     //创建第一条线程，使用start()  
    
17.                     new FirstThread().start();  
    
18.                     new FirstThread().start();  
    
19.                 }  
    
20.             }  
    
21.         }  
    
22.     }  

复制代码

2. 通过实现Runnable接口：

1. package com.zsc.everyday;  
   
2.     //通过实现 Runnable 接口的方式实现多线程  
   
3.     public class SecondThread implements Runnable {  
   
4.         private int i  ;  
   
5.         //重写 run 方法，run方法中的方法是现成的执行方法  
   
6.         public void run(){  
   
7.             for(;i<5;i++){  
   
8.                 //获取线程名称 只能使用  Thread.currentThread().getName()  
   
9.                 System.out.println(Thread.currentThread().getName()+"、"+i);  
   
10.             }  
    
11.         }  
    
12.         public static void main(String[] args) {  
    
13.             for(int i =0 ;i<5;i++){  
    
14.                 System.out.println(Thread.currentThread().getName()+"、"+i);  
    
15.                 if(i==2){  
    
16.                     SecondThread st = new SecondThread();  
    
17.                     //通过 new Thread(target,name).start();  创建线程  
    
18.                     new Thread(st,"新线程1").start();  
    
19.                     new Thread(st,"新线程2").start();  
    
20.                 }  
    
21.             }  
    
22.         }  
    
23.     }  

复制代码

3. 两种实现多线程的区别：
在使用Thread的时候只需要new一个实例出来，调用start()方法即可以启动一个线程。
Thread Test = new Thread();
Test.start();

在使用Runnable的时候需要先new一个继承Runnable的实例，之后用子类Thread调用。
Test impelements Runnable
Test t = new Test();
Thread test = new Thread(t);

两种实现范式的区别：

Thread是用extends继承；
而Runnable是用implements继承，即实现抽象类；
如果你用extends继承了别的类，还想实现线程，那就用Runnable；
反之用Thread。


4. 控制线程

jion 线程：java让一个线程等另一个线程的方法：jion() 方法；

1.   package com.zsc.everyday;  
   
2.     // join 方法 控制线程  
   
3.     public class JoinThread extends Thread{  
   
4.         //提供一个有参数的构造器，用于设置该线程的名字  
   
5.         public JoinThread(String name){  
   
6.             super(name);  
   
7.         }  
   
8.         // 重写 run 方法，定义线程执行体  
   
9.         public void run(){  
   
10.             for(int i=0;i<5;i++){  
    
11.                 //获取线程名称 只能使用  Thread.currentThread().getName()  
    
12.                 System.out.println(Thread.currentThread().getName()+"、"+i);  
    
13.             }  
    
14.         }  
    
15.         public static void main(String[] args) throws Exception {  
    
16.             //启动子线程  
    
17.             new JoinThread("新线程1").start();  
    
18.             for(int i =0 ;i<5;i++){  
    
19.                 if(i==2){  
    
20.                     JoinThread jt = new JoinThread("被join的线程");  
    
21.                     //通过 new Thread(target,name).start();  创建线程  
    
22.                     jt.start();  
    
23.                     // main线程调用了jt线程的join 方法，main 线程  
    
24.                     // 必须等jt 执行结束才会向下执行  
    
25.                     jt.join();  
    
26.                 }  
    
27.                 System.out.println(Thread.currentThread().getName()+"、"+i);  
    
28.             }  
    
29.         }  
    
30.     }  

复制代码

运行结果：

1. main、0  
   
2.     main、1  
   
3.     新线程1、0  
   
4.     新线程1、1  
   
5.     新线程1、2  
   
6.     新线程1、3  
   
7.     新线程1、4  
   
8.     被join的线程、0  
   
9.     被join的线程、1  
   
10.     被join的线程、2  
    
11.     被join的线程、3  
    
12.     被join的线程、4  
    
13.     main、2  
    
14.     main、3  
    
15.     main、4  

复制代码

5. 后台线程：他是在后台运行的，任务是为其他线程服务。
特征：如所有的前台线程都死亡了后，后台线程才会消亡。
代码：

1. package com.zsc.everyday;  
   
2.     // Daemon Thread  后台线程  
   
3.     public class DaemonThread extends Thread{  
   
4.         // 重写 run 方法，定义线程执行体  
   
5.         public void run(){  
   
6.             for(int i=0;i<5;i++){  
   
7.                 //获取线程名称 只能使用  Thread.currentThread().getName()  
   
8.                 System.out.println(Thread.currentThread().getName()+"、"+i);  
   
9.             }  
   
10.         }  
    
11.         public static void main(String[] args) throws Exception {  
    
12.             DaemonThread t = new DaemonThread();  
    
13.             //将此线程设置为后台线程  
    
14.             t.setDaemon(true);  
    
15.             //启动后台线程  
    
16.             t.start();  
    
17.             for(int i =0 ;i<5;i++){  
    
18.                 System.out.println(Thread.currentThread().getName()+"、"+i);  
    
19.             }  
    
20.             //程序执行到此处 前台程序（main线程结束）  
    
21.             //后台线程也随之结束  
    
22.         }  
    
23.     }  

复制代码

运行结果：

1. main、0  
   
2.     main、1  
   
3.     main、2  
   
4.     main、3  
   
5.     main、4  
   
6.     Thread-0、0  
   
7.     Thread-0、1  
   
8.     Thread-0、2  
   
9.     Thread-0、3  
   
10.     Thread-0、4  

复制代码

6. 线程睡眠   让当前线程停止一段时间，并进入阻塞状态，则可以调用Thread类的静态方法 sleep();

代码：

1. 
   
2.     package com.zsc.everyday;  
   
3.     import java.sql.Timestamp;  
   
4.     //  线程休眠public class SleepThread {  
   
5.         public static void main(String[] args) throws Exception {  
   
6.             Timestamp start = new Timestamp(System.currentTimeMillis());  
   
7.             System.out.println(start);  
   
8.             //线程休眠3秒  
   
9.             Thread.sleep(3000);  
   
10.             Timestamp end = new Timestamp(System.currentTimeMillis());  
    
11.             System.out.println(end);  
    
12.         }  
    
13.     }  

复制代码

运行结果：

1.   2011-12-23 12:50:57.738  
   
2.     2011-12-23 12:51:00.755  

复制代码

http://blog.csdn.net/tianshan2008/article/details/7097820

多线程有两种实现方法，分别是继承Thread类与实现Runnable接口