java创建线程有3种方式：

(1)继承Thread
(2)实现Runnable接口
(3)实现Callable接口

1、继承Thead

1. package com.java.thread;  
2.   
3. public class ThreadClient {  
4.   
5.     public static void main(String[] args) {  
6.         Print p1 = new Print();  
7.         Print p2 = new Print();  
8.         p1.start();  
9.         p2.start();  
10.   
11.     }  
12.   
13. }  
14.   
15. class Print extends Thread{  
16.     @Override  
17.     public void run(){  
18.         for(int i=0;i<10;i++){  
19.             System.out.println(Thread.currentThread().getName()+":"+i);  
20.             try {  
21.                 Thread.sleep(2000);  
22.             } catch (InterruptedException e) {  
23.                 e.printStackTrace();  
24.             }  
25.         }  
26.     }  
27. }  

2、实现Runnable接口

1. package com.java.thread;  
2.   
3. public class ThreadClient1 {  
4.   
5.     public static void main(String[] args) {  
6.         Runnable p1 = new Salesman("Jack");  
7.         Runnable p2 = new Salesman("Iris");  
8.           
9.         Thread t1 = new Thread(p1);  
10.         Thread t2 = new Thread(p2);  
11.           
12.         t1.start();  
13.         t2.start();  
14.     }  
15.   
16. }  
17.   
18. class Salesman implements Runnable{  
19.       
20.     private int ticket=100;
21.     private String name;  
22.     Salesman(String name){  
23.         this.name=name;  
24.     }  
25.       
26.     @Override  
27.     public void run(){  
28.         while(ticket>0){  
29.              System.out.println(ticket--+" is saled by "+name+","+Thread.currentThread().getName());  
30.             try {  
31.                 Thread.sleep(1000);  
32.             } catch (InterruptedException e) {  
33.                 e.printStackTrace();  
34.             }  
35.          }  
36.     }  
37. }  

3、实现Callable接口

1. package com.java.thread;  
2.   
3. import java.util.ArrayList;  
4. import java.util.List;  
5. import java.util.concurrent.Callable;  
6. import java.util.concurrent.ExecutionException;  
7. import java.util.concurrent.ExecutorService;  
8. import java.util.concurrent.Executors;  
9. import java.util.concurrent.Future;  
10.   
11. public class CallType {  
12.       
13.     public static void main(String[] args) {  
14.         ExecutorService es = Executors.newCachedThreadPool();  
15.         List<Future<String>> results = new ArrayList<Future<String>>();  
16.         for(int i=0;i<5;i++){  
17.             results.add(es.submit(new TaskWithResult(i)));  
18.         }  
19.           
20.         for(Future<String> fs : results){  
21.             try {  
22.                 System.out.println(fs.get());  
23.             } catch (InterruptedException | ExecutionException e) {  
24.                 // TODO Auto-generated catch block  
25.                 e.printStackTrace();  
26.             }  
27.         }  
28.     }  
29. }  
30.   
31. class TaskWithResult implements Callable<String>{  
32.     private int id;  
33.     public TaskWithResult(int id){  
34.         this.id = id;  
35.     }  
36.     @Override  
37.     public String call() throws Exception {  
38.         return "result of TaskWithResult" + id;  
39.     }  
40. }  

由于Java只支持单继承，所以用继承的方式创建线程，比较死板，不够灵活；用实现接口的方式创建线程，可以实现多个接口，比较灵活。
Runnable和Callable接口的区别：
(1)Callable重写的方法是call(),Runnable重写的方法是run()。
(2)Callable的任务执行后可返回值，而Runnable不能返回值。
(3)call方法可以抛出异常，run()不可以。

java 创建线程