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