多线程实现的三种方式

线程 (Thread) 是一个程序内部的一条执行流程 。

程序中如果只有一条执行流程，那这个程序就是单线程的程序。

多线程是指从软硬件上实现的多条执行流程的技术（多条线程由 CPU 负责调度执行）

Java是通过java.lang.Thread 类的对象来代表线程的。

方式一：继承Thread类

优点：编码简单

缺点：存在单继承的局限性，线程类继承Thread后，不能继承其他类，不便于扩展

public class ThreadDemo1 {
    // main方法启动时，默认是由一条主线程负责执行。
    public static void main(String[] args) {
        // 目标：掌握创建线程的方式一：继承Thread类。
        // 3、创建线程类的对象代表一个线程。
        Thread t = new MyThread();
        // 4、启动这个线程对象，才真正开启了一个线程。(线程会自动执行run方法来跑)
        t.start();

        for (int i = 0; i < 5; i++) {
            System.out.println("main线程输出 ===> " + i);
        }
    }
}

// 1、定义一个线程类继承Thread类。
class MyThread extends Thread{
    // 2、重写Thread类提供的run方法(线程执行任务的方法)
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程输出 ===> " + i);
        }
    }
}

方式二：实现Runnable接口

优点：扩展性强，实现该接口的同时还可以继承其他的类。

缺点：编程相对复杂，不能返回线程执行的结果

public class ThreadDemo2 {
    public static void main(String[] args) {
        // 目标：掌握多线程的创建方式二：实现Runnable接口。
        // 3、用任务类创建任务对象
        Runnable target = new MyRunnable();
        // 4、把线程任务对象交给一个线程对象。
        //    a、我们就得到一个线程了
        //    b、线程启动后，可以去执行任务对象的run方法执行。
        Thread t = new Thread(target);
        // 5、启动线程
        t.start();

        for (int i = 0; i < 5; i++) {
            System.out.println("main线程输出：" + i);
        }
    }
}

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

public static void main(String[] args) {
        // 目标：掌握多线程的创建方式二的匿名内部写法。
        // 1、创建Runnable接口的匿名内部类对象。
        Runnable target = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println("子线程1输出：" + i);
                }
            }
        };
        // 2、包装成线程对象
        Thread t = new Thread(target);
        // 3、启动线程
        t.start();

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

        new Thread( () -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("子线程3输出：" + i);
            }
        }).start();

        for (int i = 0; i < 5; i++) {
            System.out.println("main线程输出：" + i);
        }
    }

方式三：实现Callable接口

优点：线程任务类只是实现，可以继续继承和实现接口，扩展性强， 可以得到线程执行的结果

缺点：编程相对复杂

public static void main(String[] args) {
        // 目标：掌握多线程的创建方式三：实现Callable接口的方式。
        // 3、创建Callable对象
        Callable<String> call = new MyCallable(100);
        // 4、创建一个真正的任务对象叫：未来任务对象。
        // 未来任务对象的作用：
        //    a、未来任务对象本质是一个Runnable类型的对象，可以交给线程了！
        //    b、可以在线程执行完毕后去获取线程执行完毕后返回的结果
        FutureTask<String> task = new FutureTask<>(call);
        // 5、把未来任务对象交给线程对象。
        // public Thread(Runnable task)
        Thread t = new Thread(task);
        // 6、启动线程
        t.start();


        Callable<String> call2 = new MyCallable(200);
        FutureTask<String> task2 = new FutureTask<>(call2);
        Thread t2 = new Thread(task2);
        t2.start();

        // 怎么获取线程执行完毕后的结果呢？建议大家在全部线程启动后再拿结果
        try {
            // 注意：当主线程执行到这里取第一个线程的结果时，如果第一个线程没有执行完毕
            // 会暂定等待第一个线程执行完毕后，再往下走！
            String rs = task.get();
            System.out.println(rs);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }

        try {
            String rs = task2.get();
            System.out.println(rs);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

// 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 = 1; i <= n; i++) {
            sum += i;
        }
        return "子线程求出了1-" + n + "的和是：" + sum;
    }