[JAVA]创建多线程的三种方式与区别

• 继承Thread类创建线程
• 实现Runnable接口创建线程
• Callable接口创建线程

要学习创建线程，我们要通过代码来演示，这里我们可以通过实现以下参赛者跑步的场景来展开。

模拟以下场景

                                                           模拟10秒短跑程序

假设，这里有三名参赛者，十秒钟时间内同时向前奔跑，我们要统计这三名参赛者分别跑了多少米，如果通过Java语言来模拟，我们是会有四个线程（main主线程 参赛者A 参赛者B 参赛者C ）

1.通过继承Thread类的方式模拟10秒短跑程序

• 第一步：继承Thread类
• 第二步：重写run()方法
• 第三步：调用start( )方法启动线程

首先我们在ThreadSample类中新建内部类并继承父类Thread来创建线程，并重写Thread类中run方法

//记录参赛者在十秒之内的跑步距离
public class ThreadSample {
    class Runner extends Thread { //内部类
        public void run() {
            Integer speed = new Random().nextInt(10); //利用随机数生成速度
            for (int i = 1; i <= 10; i++) {
                System.out.println("第" + i + "秒" + this.getName() + "已跑到" + (i * speed) + "米(" + speed + "每秒）");
            }

        }

    }

class Runner extends Thread {

定义了Runner类继承Thread类创建线程

Integer speed = new Random().nextInt(10); ：

这段代码在run方法中调用了Random用于生成随机数的类，然后使用nextInt（10）方法，生成0 — 9的随机数，这个生成随机数将作为速度的数组
 

然后我们再建立start方法体，用于记录参赛者跑的动作

public void start() {
        Runner threadA = new Runner();  //实例化类       //实例化并不会决定程序的运行，只有调用start方法时，这个线程才会被创建和开始运行
        threadA.setName("参赛者A"); //调用setName，给当前线程赋名字
        Runner threadB = new Runner();
        threadB.setName("参赛者B");
        Runner threadC = new Runner();
        threadC.setName("参赛者C");
        threadA.start();   //调用start()方法 开始新进程的创建和运行
        threadB.start();
        threadC.start();

    }

 最后在main主函数实例化ThreadSample类并调用start方法体

public static void main(String[] args) {
        new ThreadSample().start();
    }

 运行结果：

实现Runnable接口模拟10秒短跑程序

第一步：实现接口Runnable

第二步：实现自带的run方法体

第三步：实例化Runner后，将对象作为参数传入Thread线程类中

第三步：调用start( )方法启动线程

创建一个ThreadSample2类，再定义内部类Runner ，这里不再像上面方法继承Thread类，而是实现一个Runnable接口，Runnable接口它提供了一种定义可执行任务的方式，用来实现多线程处理程序，在Runnable接口中必须要实现一个方法（run方法），此run方法与以上run方法体类似，这里只需注意在打印语句中对于当前线程名字的描述

    class Runner implements  Runnable { //Runnable是Java。lang包下所提供的接口，用来实现多线程处理程序
        @Override
        public void run() {
            Integer speed = new Random().nextInt(10); //利用随机数生成速度
            for (int i = 1; i <= 10; i++) {
                System.out.println("第" + i + "秒" + Thread.currentThread().getName() + "已跑到" + (i * speed) + "米(" + speed + "每秒）");
            }      //Thread是线程类 提供了一个静态方法currentThread

        }
    }

 Thread.currentThread().getName() ：

Runnable无法像使用Thread类在打印语句中获取到getName线程名字，它没有getName这个方法，这里我们可以用Thread.currentThread().getName(),Thread是线程类，在线程类中他提供了一个静态方法，获取到当前线程然后调用getName，得到当前线程的名称

在当前类中增加start方法

public void start(){
        Runner runner =new Runner();   
        Thread threadA= new Thread(runner);//将runner对象作为线程参数传入其中，在调用线程中的start方法
        threadA.setName("参赛者A");
        Thread threadB =new Thread(runner);
        threadB.setName("参赛者B");
        Thread threadC =new Thread(runner);
        threadC.setName("参赛者C");
        threadA.start();
        threadB.start();
        threadC.start();

    }

在主函数main中调用

public static void main(String[] args) {
        new ThreadSample2().start();
    }

运行结果：

通过Callable接口模拟10秒短跑程序

新建内部类Runner，并连接Callable接口，这里Callable接口需要定义一个泛型，利用Callable接口我们实现多线程程序，每一个线程在执行完以后，它会有一个返回值

public class ThreadSample3 {              //涉及线程池
    class Runner implements Callable<Integer>{   //内部类

        public String name;

        @Override
        public Integer call() throws Exception {  //实现Runner中的方法call()
            Integer speed =new Random().nextInt(10);
            Integer result =0;
            for(int i=1;i<=10;i++){
                Thread.sleep(1000);
                result=i*speed;
           System.out.println("第" + i + "秒" + this.name + "已跑到" + (i * speed) + "米(" + speed + "每秒）");

            }
            return result;
        }

再模拟参赛者开始跑的方法start()

 public void start() throws ExecutionException, InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        Runner threadA=new Runner();
        threadA.name ="参赛者A";
        Runner threadB=new Runner();
        threadB.name ="参赛者B";
        Runner threadC=new Runner();
        threadC.name ="参赛者C";
        Future<Integer> r1= executorService.submit(threadA);
        Future<Integer> r2= executorService.submit(threadB);
        Future<Integer> r3=  executorService.submit(threadC);
        executorService.shutdown(); //等待所有线程执行完毕后，关闭线程池
        System.out.println(threadA.name+"累计跑了"+r1.get()+"米");
        System.out.println(threadB.name+"累计跑了"+r2.get()+"米");
        System.out.println(threadC.name+"累计跑了"+r3.get()+"米");
    }

 ExecutorService executorService = Executors.newFixedThreadPool(3);:

创建了一个固定大小线程池的 ExecutorService，newFixedThreadPool(3)方法创建一个固定大小的线程池，其中参数3指定了线程池中的线程数量。

 Future<Integer> r1= executorService.submit(threadA);：

这行代码的作用是将一个任务提交给前面创建的线程池executorService执行，并返回一个Future<Integer>对象来表示这个任务的结果。

在主函数main中调用

  public static void main(String[] args) throws ExecutionException, InterruptedException {
        new ThreadSample3().start();
    }

运行结果

通过这种方式，通过实现Callable接口进行开发，有着较好的功能，除了实现线程本身功能以外，还可以允许出现返回值。

这种带有返回值的线程处理，可以用于一些科学运算，比如用于计算量很大的任务，为了让计算机发挥充分的性能，我们把它拆分成多个线程，分到不同的CPU内核上来进行处理，这里每个线程计算的结果都可以通过Future对象接受到，当所有线程处理完成，将每一个线程进行汇总或再进行其他运算。

总之，利用Callable接口它的优势是允许线程执行后将值进行返回。

三种创建方式进行对比

• 继承Thread，java只支持单继承，对这种方法不太友好，不推荐使用
• 实现Runnable接口，Java编程友好，但无法返回执行后的数据
• 实现Callable接口，可以返回多线程执行结果，编程稍显复杂