【多线程】多线程（二）多线程的三种创建方式及区别_跳跃式线程分工连续式线程区别-CSDN博客

本文链接：https://blog.csdn.net/qq_34416331/article/details/102851175

在JAVA中实现多线程有三种方式：

  一、继承 Thread 类

  二、实现 Runnable 接口

  三、继承 Callable 类

一、继承 Thread 类

直接继承 Thread 类是最简单的多线程实现方式，你可以根据实际需求新建出多种不同的子类线程，并重写他们的 run 方式来实现不同类型的线程干不同的事情，并让他们有规划的相互合作。

优点：直接继承就可以使用，代码简单清晰

缺点：由于 JAVA 是单继承的，继承了 Thread 类就无法继承其他类

新建类： MainThread.java

/**
 * @author tom
 * @date 2019-11-01 09:37
 * @Description 通过继承 Thread 类来创建线程
 */
public class MainThread extends Thread{

    public static void main(String[] args) {

        // 新建了一个 MainThread 的类实例，这个类继承了 Thread
        MainThread thread1 = new MainThread();
        // 设置这个实例的名称（可重复）
        thread1.setName("tom thread");
        // 启动线程，此时线程开始跑 run 方法
        thread1.start();

        System.out.println("main over");

        // 运行 main 函数的线程叫主线程，循环打印主线程的内容
        // 由于主线程和其他线程存在竞争关系，故可以在打印台看到两种线程存在交互情况
        for (int i=0; i<50; i++) {
            System.out.println(Thread.currentThread().getName() + " i = " + i);
        }
    }


    /**
     * @author tom
     * @date 2019/11/1 9:39
     * @params
     * @return
     * @Description 继承了 Thread 类，必须重写 run 方法，来让这一类的线程做自己想要让他做的事情
    */
    @Override
    public void run() {
        // 循环打印出这个线程的名字
        for (int i=0; i<50; i++) {
            System.out.println(Thread.currentThread().getName() + " i = " + i);
        }
    }
}

运行类中的 main 方法，会得到：

可以看到存在主线程 main 和子线程 tom 的打印日志是交互显示的，证明线程之间是交互执行的，而不是同时并行执行。若同时并行执行，应是 main 一条， tom 一条。

......
tom thread i = 14
tom thread i = 15
tom thread i = 16
main i = 22
main i = 23
main i = 24
main i = 25
main i = 26
main i = 27
main i = 28
tom thread i = 17
tom thread i = 18
main i = 29
main i = 30
main i = 31
main i = 32
main i = 33
main i = 34
main i = 35
main i = 36
main i = 37
tom thread i = 19
tom thread i = 20
tom thread i = 21
main i = 38
main i = 39
tom thread i = 22
tom thread i = 23
tom thread i = 24
tom thread i = 25
tom thread i = 26
tom thread i = 27
tom thread i = 28
......

二、实现 Runnable 接口

由于 JAVA 的单继承特性，继承了 Thread 的类无法再成为其他类的子类，而通过 Runnable 接口就可以解决这种情况，让我们的线程实现类可以继承其他类。

新建类： MainRunnable.java


/**
 * @author tom
 * @date 2019-11-01 09:59
 * @Description 使用 Runnable 接口创建子线程
 */
public class MainRunnable implements Runnable {

    public static void main(String[] args) {

        // 创建 Runnable 实例
        MainRunnable mRu = new MainRunnable();

        // 创建 Thread 并传入 Runnable 实例
        Thread th1 = new Thread(mRu);
        // 设置子线程名称
        th1.setName("children thread");
        // 开启子线程
        th1.start();

        for (int i = 0; i < 50; i++) {
            System.out.println(Thread.currentThread().getName() + " i = " + i);
        }

    }

    /**
     * @author tom
     * @date 2019/11/1 10:00
     * @params
     * @return
     * @Description this is a function
    */
    @Override
    public void run() {
        // 打印子线程信息
        for (int i = 0; i < 50; i++) {
            System.out.println(Thread.currentThread().getName() + " i = " + i);
        }
    }
}

运行 main 方法，会得到：

......
children thread i = 30
children thread i = 31
children thread i = 32
main i = 19
main i = 20
children thread i = 33
children thread i = 34
children thread i = 35
main i = 21
main i = 22
main i = 23
main i = 24
main i = 25
main i = 26
main i = 27
main i = 28
main i = 29
main i = 30
main i = 31
main i = 32
main i = 33
main i = 34
main i = 35
children thread i = 36
children thread i = 37
children thread i = 38
children thread i = 39
children thread i = 40
children thread i = 41
main i = 36
main i = 37
main i = 38
main i = 39
main i = 40
main i = 41
children thread i = 42
children thread i = 43
children thread i = 44
children thread i = 45
children thread i = 46
children thread i = 47
children thread i = 48
children thread i = 49
main i = 42
main i = 43
main i = 44
main i = 45
......

三、继承 Callable 类

继承 Callable 类可以实现线程的回调以及抛出异常，而前面两种不能。

新建类： MainCallable.java

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

/**
 * @author tom
 * @date 2019-11-01 10:08
 * @Description
 */
public class MainCallable implements Callable<Integer> {

    public static void main(String[] args) {

        // 构建 Callable 实例类
        MainCallable mCall = new MainCallable();
        // 通过 FutureTask 类来实现回调
        // 需要指定回调类型，此时回调类型是 Integer，并将call实例类添加到 FutureTask 实例类中
        FutureTask<Integer> mFutureTask = new FutureTask<>(mCall);

        // 构建线程，并在构建时将 FutureTask 实例传入
        Thread mThread = new Thread(mFutureTask);
        // 设置子线程名
        mThread.setName("children thread");
        // 开启线程
        mThread.start();

        // 重要的一步，通过 FutureTask 实例的 get() 方法获取到线程返回的结果
        try {
            int count  = mFutureTask.get();
            System.out.println("callable count = " + count);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

    }

    /**
     * @author tom
     * @date 2019/11/1 10:08
     * @params
     * @return
     * @Description this is a function
    */
    @Override
    public Integer call() throws Exception {
        int count = 0;
        for (int i=0; i<50; i++) {
            count++;
            System.out.println(Thread.currentThread().getName() + " i = " + i);
        }
        return count;
    }
}

运行 main 方法，会得到：

......
children thread i = 32
children thread i = 33
children thread i = 34
children thread i = 35
children thread i = 36
children thread i = 37
children thread i = 38
children thread i = 39
children thread i = 40
children thread i = 41
children thread i = 42
children thread i = 43
children thread i = 44
children thread i = 45
children thread i = 46
children thread i = 47
children thread i = 48
children thread i = 49
callable count = 50

可以看到最终 main 方法里拿到的返回值是50。