Java创建多线程的三种方式

1.方式一:继承Thread类

1.1流程:

1.定义一个子类MyThread继承线程类java.lang.Thread，重写run()方法.
2.创建MyThread类的对象
3.调用线程对象的start()方法启动线程.

1.2优缺点:

1.优点:编码简单
2.缺点:线程类已经继承Thread，无法继承其他类，不利于扩展。

1.3代码:

public class ThreadDemo01 {
    public static void main(String[] args) {
//        3.创建线程对象
        Thread th = new MyThread();
        th.start();
        for (int i = 0; i < 5; i++) {
            System.out.println("主线程输出:"+i);
        }
    }
}

//1.定义一个线程类继承Thread类
class MyThread extends Thread {
//    2.重写run方法,定义线程行为

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程输出:"+i);
        }
    }
}

1.4运行结果:

2.方式二:实现Runnable接口

2.1流程:

1.定义一个线程任务类MyRunnable实现Runnable接口，重写run()方法
2.创建MyRunnable任务对象
3.把MyRunnable任务对象交给Thread处理。
4.调用线程对象的start()方法启动线程

2.2优缺点:

1.优点:线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强。
2.缺点:编程多一层对象包装，如果线程有执行结果是不可以直接返回的。

2.3代码:

public class ThreadDemo02 {
    public static void main(String[] args) {
//        3.创建任务对象
        Runnable target = new MyRunnable();
//        4.把任务对象交给Thread处理
        Thread th = new Thread(target);
//        5.启动线程
        th.start();
        for (int i = 0; i < 5; i++) {
            System.out.println("主线程输出:"+i);
        }
    }

}
//1.定义一个线程任务类,实现Runnable接口
class MyRunnable implements Runnable {
//    2.重写run方法
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程输出:"+i);
        }
    }
}

2.4运行结果:

3.方式三:实现Callable接口

3.1流程:

1.得到任务对象:
①定义类实现Callable接口，重写call方法，封装要做的事情。
②用FutureTask把Callable对象封装成线程任务对象。
2.把线程任务对象交给Thread处理。
3.调用Thread的start方法启动线程，执行任务
4.线程执行完毕后、通过FutureTask的get方法去获取任务执行的结果。

3.2优缺点:

1.优点:
①线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强。
②可以在线程执行完毕后去获取线程执行的结果。
2.缺点:编码复杂

3.2代码:

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class ThreadDemo03 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
//        3.创建任务对象
        Callable<String> call = new MyCallable(100);
//        4.把callable任务对象交给FutureTask对象
        //FutureTask对象的作用1:是Runnable的对象,实现了Runnable接口,可以传递给Thread对象
        //FutureTask对象的作用2:可以在线程执行完毕之后通过调用其get方法得到线程执行完成的结果
        FutureTask<String> f1 = new FutureTask<>(call);
//        5.交给线程处理
        Thread th1 = new Thread(f1);
        th1.start();
        String rs1 = f1.get();
        System.out.println("线程1结果:"+rs1);


//        线程2
        Callable<String> call2 = new MyCallable(200);
        FutureTask<String> f2 = new FutureTask<>(call2);
        Thread th2 = new Thread(f2);
        th2.start();
        String rs2 = f2.get();
        System.out.println("线程2结果:"+rs2);

        //线程3
        Callable<String> call3 = new MyCallable(50);
        FutureTask<String> f3 = new FutureTask<>(call3);
        Thread th3 = new Thread(f3);
        th3.start();
        String rs3 = f3.get();

        System.out.println("线程3结果:"+rs3);



    }

}
//1.定义一个任务类,实现Callable接口,声明线程任务执行完毕后的结果数据类型
class MyCallable implements Callable<String>{
    private int n;
    public MyCallable(int n){
        this.n = n;
    }
//    2.重写call方法
    @Override
    public String call() throws Exception {
        int sum = 0;
        for (int i = 0;i<n;i++){
            sum += i;
        }
        return "线程的执行结果是:"+sum;
    }
}

3.4运行结果: