多线程的三种种实现方式以及过程模拟

多线程

1、多线程的实现方式：

1、通过创建一个类继承Thread类，然后创建该类的对象，然后调用该对象的start（）方法，start（）方法会调用native方法start0(),该方法由虚拟机直接调用，底层是C/C++实现，然后开启一个线程进入就绪态由CPU调度。start0（）方法会执行该类重写的run()方法。

2、通过创建一个类实现Runable接口，创建该类的对象，再实现Thread类，将该类的对象作为构造参数传给Thread类对象，再调用Thread类对象的start（）方法


3、通过创建一个类实现Callable接口，重写call（）方法，再创建该类的对象将其封装进FutureTask对象，FutureTask类间接实现了Runnable接口，再将FutureTask对象交给Thread对象，启动start（）方法启动线程，最后可以调用FutureTask对象的get()方法来得到线程的返回结果。

注：Thread类也是实现了Runable接口，由于Java是单继承。有些类已经继承了其他类，不可以再继承Thread类，只能通过实现Runable接口
与前两种方式不同的是，通过实现Callable接口创建线程可以返回线程的运行结果。

模拟类实现Runable接口创建新线程

//测试类
public class Runable_Simulate {
    public static void main(String[] args) {
    //模拟Runable
        ThreadSimulate threadSimulate = new 				   ThreadSimulate(new RunableTest());
        threadSimulate.start();
    //模拟Thread
 		ThreadTest threadTest = new ThreadTest();
        threadTest.start();
    }
}

//ThreadSimulate模拟Thread类
class ThreadSimulate implements Runnable{
   private Runnable target = null;

	public ThreadSimulate() {
   	 }//为模拟实现Thread的无参构造器
    public ThreadSimulate(Runnable target) {
        this.target = target;
    }//为模拟实现Runable的有参构造器
 public void start(){
        start0();
 }
 public void start0(){
     System.out.println("开启了新线程");
        run();
 }
    @Override
    public void run() {
        if (target!=null){
            target.run();
        }
    }
}

//需要开启线程的模拟Runable的类
class RunableTest implements Runnable{
    @Override
    public void run() {
        System.out.println("模拟测试Runable，代理模式");
    }
}

//需要开启线程的模拟Thread的类
class ThreadTest extends ThreadSimulate{
    @Override
    public void run() {
        System.out.println("模拟测试Thread，代理模式");
    }
}

实现Callable接口：

public class CallableThread implements Callable<String> {
    //实现Callable接口，指定线程返回结果类型为String
    int n ;
    public CallableThread(int n) {
        this.n = n;
    }

    public static void main(String[]args) throws ExecutionException, InterruptedException {
        //创建CallableThread对象，传入参数
        CallableThread callableThread = new CallableThread(200);
        //将CallableThread对象封装进FutureTask对象，
        // FutureTask实现了RunnableFuture接口，RunnableFuture接口继承自Runnable接口
        FutureTask<String> stringFutureTask = new FutureTask<>(callableThread);
        //创建Thread对象，并将FutureTask对象交给Thread，开启线程
        new Thread(stringFutureTask).start();
        //通过FutureTask对象的get()方法获得线程的返回结果
        stringFutureTask.get();
    }

    @Override
    public String call() throws Exception {
        //重写call（）方法，返回类型为String
        int sum =0;
        for (int i = 0; i < n; i++) {
            sum+=n;
        }
        return "0~"+n+"的所有整数的和为："+sum;
    }
}