java 实现多线程 3种方式

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

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

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

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

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

 import java.util.concurrent.Callable;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.Future; class MyThread extends Thread{
     //采用集成的方式实现线程
     public void run(){
         for(int i=0; i<=5;i++){
             try {
                 Thread.sleep(1000);
             } catch (InterruptedException e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }
             System.out.println("MyThread  集成方式实现 the i ="+i);         }
     } } class MyImpThread implements Runnable{     @Override
     public void run() {
         for(int i=0; i<=5;i++){
             try {
                 Thread.sleep(1000);
             } catch (InterruptedException e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }
             System.out.println("MyImpThread 实现接口的方式实现 the i ="+i);         }     } } class CallableTest implements Callable<Object>{     @Override
     public Object call() throws Exception {
         for(int i=0; i<=5;i++){
             try {
                 Thread.sleep(1000);
             } catch (InterruptedException e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }
             System.out.println("Callable类型 实现接口的方式实现 the i ="+i);         }
         return "Callable 接口好";
     } } public class TestThread {     public static void main(String[] args) {
         //1.集成方式
         MyThread my = new MyThread();
         my.start();         //2.实现接口方式
         Thread thread = new Thread(new MyImpThread());
         thread.start();         //3.实现Callable 接口
         ExecutorService threadPool = Executors.newSingleThreadExecutor();
         Future<Object> future = threadPool.submit(new CallableTest());         try {
             Thread.sleep(2000); //让主线程先休眠2s;
         } catch (InterruptedException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }         for(int i=0; i<=5;i++){
             System.out.println("当前主线程 the i ="+i);         }     } }

运行结果：

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线程都可以很好运行，加上主线程，一共四个线程在同时运行，各个线程之间来回切换。