Java实现多线程的三种方法

继承Thread类的方式进行实现

实现步骤一些疑问

1、为什么要重写run方法2、run方法和start方法的区别 实现Runnable接口的方式进行实现

实现步骤注意 利用Callable和Future接口方式实现

实现步骤注意 三种方式的对比

定义一个类MyThread继承Thread类
在MyThread类中重写run0方法

public class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("thread is opened..." + i);
        }
    }
}

创建MyThread类的对象
启动线程

MyThread myThread = new MyThread();
MyThread myThread1 = new MyThread();
MyThread myThread2 = new MyThread();
myThread.start();
myThread1.start();
myThread2.start();

多线程在开启之后执行的是run方法中的代码，虽然是对象调用start方法，但是执行的方法内容是run方法中的内容
run方法中封装的是将要被线程执行的代码，所以必须要重写run方法

run方法：封装线程执行的代码，直接调用，相当于普通方法的调用，并没有开启线程。
start方法：启动线程；然后由VM调用此线程的run方法
底层实现是start方法本身是一个native修饰的本地方法，和本地操作系统进行交互

定义一个类MyRunnable实现Runnable接口
在MyRunnable类中重写run方法

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("fun 2 is running***" + i);
        }
    }
}

创建MyRunnable类的对象
创建Thread类的对象，把MyRunnable对象作为构造方法的参数
启动线程

//创建参数对象
        MyRunnable myRunnable = new MyRunnable();
        //创建线程对象
        Thread thread = new Thread(myRunnable);
        thread.start();

        MyRunnable myRunnable1 = new MyRunnable();
        //创建线程对象
        Thread thread1 = new Thread(myRunnable1);
        thread1.start();

第二种实现方法先要实现接口，然后要创建参数对象（此时不能直接调用start方法）。然后将参数对象传递到Thread构造方法中，最后用thread对象调用start方法

定义一个类MyCallable实现Callable接口
在MyCallable类中重写call方法

public class MyCallable implements Callable {
    @Override
    public String call() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.println("running !!!" + i);
        }
        //返回值表示线程运行完之后的结果
        return "end";
    }
}

创建MyCallable类的对象

//线程开启之后需要执行里面的call方法
MyCallable myCallable = new MyCallable();

创建Future的实现类FutureTask对象，把MyCallable对象作为构造方法的参数

//可以获取线程执行完毕后的结果，也可以作为参数传递给thread对象
FutureTask task = new FutureTask(myCallable);

创建Thread类的对象，把FutureTask对象作为构造方法的参数

//FutureTask<>实现了runnable接口，所以可以直接传递给threa的构造方法
Thread thread = new Thread(task);
thread.start();

启动线程

完整的main方法：

public class Main {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //线程开启之后需要执行里面的call方法
        MyCallable myCallable = new MyCallable();
        //可以获取线程执行完毕后的结果，也可以作为参数传递给thread对象
        FutureTask task = new FutureTask(myCallable);
        //FutureTask<>实现了runnable接口，所以可以直接传递给threa的构造方法
        Thread thread = new Thread(task);
        thread.start();
        String s = task.get();
        System.out.println(s);
    }
}

该实现方法需要两次传参到两个构造函数中。在重写call方法的时候是有返回值的，返回值表示线程运行完之后的结果，这也是和上面两种方法最大的不同，能在线程执行完后根据实际生产需求返回一些值。