java 实现多线程 3种方式

java实现多线程可以有以下三种方式： 

（1）继承Thread 类，重写其run()方法；

（2）实现Runnable接口，实现其run() 方法；

(3) 实现Callable 接口，重写call() 方法；

下面以实际的例子做一下展示

 1 import java.util.concurrent.Callable;
 2 import java.util.concurrent.ExecutorService;
 3 import java.util.concurrent.Executors;
 4 import java.util.concurrent.Future;
 5 
 6 class MyThread extends Thread{
 7     //采用集成的方式实现线程
 8     public void run(){
 9         for(int i=0; i<=5;i++){
10             try {
11                 Thread.sleep(1000);
12             } catch (InterruptedException e) {
13                 // TODO Auto-generated catch block
14                 e.printStackTrace();
15             }
16             System.out.println("MyThread  集成方式实现 the i ="+i);
17             
18         }
19     }
20     
21 }
22 
23 class MyImpThread implements Runnable{
24 
25     @Override
26     public void run() {
27         for(int i=0; i<=5;i++){
28             try {
29                 Thread.sleep(1000);
30             } catch (InterruptedException e) {
31                 // TODO Auto-generated catch block
32                 e.printStackTrace();
33             }
34             System.out.println("MyImpThread 实现接口的方式实现 the i ="+i);
35             
36         }
37         
38     }
39     
40 }
41 
42 class CallableTest implements Callable<Object>{
43 
44     @Override
45     public Object call() throws Exception {
46         for(int i=0; i<=5;i++){
47             try {
48                 Thread.sleep(1000);
49             } catch (InterruptedException e) {
50                 // TODO Auto-generated catch block
51                 e.printStackTrace();
52             }
53             System.out.println("Callable类型 实现接口的方式实现 the i ="+i);
54             
55         }
56         return "Callable 接口好";
57     }
58     
59 }
60 
61 public class TestThread {
62 
63     public static void main(String[] args) {
64         //1.集成方式
65         MyThread my = new MyThread();
66         my.start();
67          
68         //2.实现接口方式
69         Thread thread = new Thread(new MyImpThread());
70         thread.start();
71         
72         //3.实现Callable 接口
73         ExecutorService threadPool = Executors.newSingleThreadExecutor();
74         Future<Object> future = threadPool.submit(new CallableTest());
75         
76         try {
77             Thread.sleep(2000); //让主线程先休眠2s;
78         } catch (InterruptedException e) {
79             // TODO Auto-generated catch block
80             e.printStackTrace();
81         }
82         
83         for(int i=0; i<=5;i++){
84             System.out.println("当前主线程 the i ="+i);
85             
86         }
87         
88     }
89 
90 }

运行结果：

MyImpThread 实现接口的方式实现 the i =0
MyThread 集成方式实现 the i =0
Callable类型 实现接口的方式实现 the i =0
MyImpThread 实现接口的方式实现 the i =1
MyThread 集成方式实现 the i =1
Callable类型 实现接口的方式实现 the i =1
当前主线程 the i =0
当前主线程 the i =1
当前主线程 the i =2
当前主线程 the i =3
当前主线程 the i =4
当前主线程 the i =5
MyImpThread 实现接口的方式实现 the i =2
MyThread 集成方式实现 the i =2
Callable类型 实现接口的方式实现 the i =2
MyImpThread 实现接口的方式实现 the i =3
MyThread 集成方式实现 the i =3
Callable类型 实现接口的方式实现 the i =3
MyImpThread 实现接口的方式实现 the i =4
MyThread 集成方式实现 the i =4
Callable类型 实现接口的方式实现 the i =4
MyImpThread 实现接口的方式实现 the i =5
MyThread 集成方式实现 the i =5
Callable类型 实现接口的方式实现 the i =5

可以看出，三种方式实现的java线程都可以很好运行，加上主线程，一共四个线程在同时运行，各个线程之间来回切换。

posted @ 2015-08-22 17:10  yytlmm  阅读(179)  评论(0)  编辑  收藏  举报