创建线程并启动-创建线程的前三种方式

  大家好，我是爱编程的喵喵。双985硕士毕业，现担任全栈工程师一职，热衷于将数据思维应用到工作与生活中。从事机器学习以及相关的前后端开发工作。曾在阿里云、科大讯飞、CCF等比赛获得多次Top名次。现为CSDN博客专家、人工智能领域优质创作者。喜欢通过博客创作的方式对所学的知识进行总结与归纳，不仅形成深入且独到的理解，而且能够帮助新手快速入门。

  本文主要介绍了创建线程并启动-创建线程的前三种方式，希望能对学习线程的同学有所帮助。

1. 创建线程并启动

  java中主线程、垃圾回收线程、异常处理线程的创建、死亡等生命周期均由别人（可能是系统，也可能是java JDK）帮我们做了，因此不需要自己操心。这里我们关注的是在主线程中创建子线程以及子线程中创建孙线程…

// java伪代码
public class Thead1 {
    public static void main(String[] args) {
        System.out.println("我是主线程的第一行代码");
        System.out.println("我是主线程的第一行代码");
        ......
        创建子线程对象（可以创建多个子线程）;
        子线程准备就绪;
        运行子线程;
        子线程结束;
        "主线程的其他代码";
    }
}

• java创建线程一共有四种方式：
  • 继承java.lang.Thread类
  • 实现Runnable接口
  • jdk1.5新增：实现Callable接口
  • jdk1.5新增：使用线程池
• 本章主要介绍前三种方式，第四种线程池的方法内容较多，且依赖于Runnable和Callable，单独一章介绍

2. 方式一：继承Thread类

• 步骤：
  • 创建一个继承于Thread类的子类，并重写Thread类的run方法，该方法就是子线程具体要执行的内容（run方法是非静态方法）
  • 新建一个上述类的对象，即线程对象（生命周期-新建）（如果有多个线程，需要创建多个Thread对象）
  • 调用线程对象的start()方法，其作用为：①启动当前线程 (生命周期-准备就绪)② 调用当前线程的run()。因此run方法很重要，包含线程真正要做的实质内容。
  • run方法执行完成，线程自动消亡（生命周期-死亡）
• 注意：
  • 一定要调用start方法，不能手动调用run方法，如果自己手动调用run()方法，那么就只是普通方法，没有启动多线程模式。run()方法由JVM调用，什么时候调用，执行的过程控制都有操作系统的CPU调度决定。
  • 一个线程对象只能调用一次start()方法启动，如果重复调用了，则将抛出异常“IllegalThreadStateException”
  • Thread.currentThread().getName()：获取当前线程的名称
  • 阅读源码，Thread类实现了Runnable接口（public class Thread implements Runnable {xxx}）
  • 上述步骤没有看到准备就绪–>运行 过程的代码，是因为该过程"获取CPU执行权"是系统帮我们操作的，当start后，线程准备就绪，系统会根据CPU使用情况，调度线程（执行线程），线程执行完毕后，就会自动消亡。

package com.cn.created;


/**
 * 1. 创建一个继承Thread类的子类，并重写run方法
 */
class SubThread extends Thread{
    @Override
    public void run(){
        // 遍历5以内的数
        for (int i = 0; i < 5; i++){
            System.out.println(Thread.currentThread().getName() + ":" + i);  // static Thread currentThread(): 返回当前线程  String getName(): 返回线程的名称
        }
    }
}

public class AThread {
    public static void main(String[] args) {
        // 主线程代码
        String a1 = "我是主线程1";
        System.out.println(a1);
        // 2. 创建Thread子类对象
        SubThread t1 = new SubThread();
        // 3. 调用对象的start方法
        t1.start();

        // 一个线程对象只能调用一次start()方法，新建一个线程对象，遍历5以内数字
        SubThread t2 = new SubThread();
        t2.start();

        // 以下是主线程
        String a2 = "我是主线程2";
        System.out.println(a2);
    }
}

• 每次执行结果都是不一样的，可以发现上例子线程的执行不影响主线程（子线程还没执行完，a2已经打印出来了，t1、t2也没有必然的顺序）

3. 方式二：实现Runnable接口

• 步骤：
  • 创建一个实现了Runnable接口的类，并实现Runnable中的抽象方法：run()，该方法就是子线程具体要执行的内容
  • 创建实现类的对象（如果有多个线程，只需要创建一个Runnable实现类的对象）
  • 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象，即线程对象（生命周期-新建）（如果有多个线程，需要创建多个Thread对象）
  • 调用线程对象的start()方法，其作用为：①启动当前线程 (生命周期-准备就绪)② 调用当前线程的run()。因此run方法很重要，包含线程真正要做的实质内容。
  • run方法执行完成，线程自动消亡（生命周期-死亡）

package com.cn.created;


/**
 * 1. 实现Runnable接口,并实现run方法
 */
class ImlRunnalbe implements Runnable{
    @Override
    public void run(){
        for (int i = 0; i < 5; i++){
            System.out.println(Thread.currentThread().getName() + ":" + i);
        }
    }
}

public class BRunnable {
    public static void main(String[] args) {
        String a1 = "我是主线程1";
        System.out.println(a1);

        // 2. 新建实现类的对象
        ImlRunnalbe imlRunnalbe = new ImlRunnalbe();
        // 3. 将新建的类对象作为参数传到Thread类构造器中
        Thread t1 = new Thread(imlRunnalbe);
        // 4. 调用start方法
        t1.start();

        // 再起一个线程
        Thread t2 = new Thread(imlRunnalbe);
        t2.start();

        String a2 = "我是主线程2";
        System.out.println(a2);
    }
}

4. 方式三：实现Callable接口

• Callable接口实现多线程是java1.5以后新增的。

• 步骤：

  • 创建一个实现了Callable接口的类，并实现Callable中的抽象方法：call，该方法就是子线程具体要执行的内容。且该call方法与继承Thread方式与实现Runnable方式的不同在于：
    • call()可以有返回值的，一般使用Object类型（在最后一步通过get方法得到的是Object类型结果）
    • Callable是支持泛型的
    • call()可以抛出异常，被外面的操作捕获，获取异常的信息
  • 创建实现callable接口的类对象（如果有多个线程，只需要创建一个Callable对象）
  • 将此Callable接口实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask的对象（如果有多个线程，需要创建多个FutureTask对象）
  • 将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread线程对象（如果有多个线程，需要创建多个Thread对象）
  • 调用线程对象的start()方法
  • 父线程调用FutureTask的get()方法，得到call的返回值，返回值类型为Object

• 相较于继承Thread方式和实现Runnable方式，实现Callable接口有以下不同：

  • 重写的是call方法，且该方法允许有返回值，可以使用泛型，可以抛出异常
  • 在步骤上多了一个FutureTask对象

package com.cn.created;

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

/**
 * 1.创建一个实现了Callable接口的类，并实现Callable中的抽象方法
 *      - 该call方法允许有返回值
 *      - 该call方法可以抛出异常
 */
class SubCall implements Callable {
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 0; i <= 10; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
            sum += i;
        }
        // 强制等待5s，观察主线程是否会等待子线程结束才能获取返回值
        Thread.sleep(5000);
        return sum;
    }
}

public class CCallable {
    public static void main(String[] args) {
        // 2. 创建实现callable接口的类对象
        SubCall subCall = new SubCall();
        // 3. 创建FutureTask对象，并将subCall传进去
        FutureTask futureTask1 = new FutureTask(subCall);
        FutureTask futureTask2 = new FutureTask(subCall);
        // 4. 创建线程对象，并将futureTask对象传进去
        Thread t1 = new Thread(futureTask1);
        Thread t2 = new Thread(futureTask2);
        t1.setName("线程1");
        t2.setName("线程2");
        // 5. 调用线程对象的start方法
        t1.start();
        t2.start();
        // 6. 打印主线程
        System.out.println("======================");
        // 7. 获取子线程的返回值
        try {
            //get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
            Object mySum1 = futureTask1.get();
            Object mySum2 = futureTask2.get();
            System.out.println("子线程1总和为：" + mySum1);
            System.out.println("子线程1总和为：" + mySum2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

  从上例的运行结果，可以看出，主线程的中打印===================并不受子线程的影响，即不需要等待子线程结束，主线程与子线程各运行各的。但是主线程中futureTask1和futureTask2对象的get方法（获取子线程返回的结果）需要等子线程结束才能得到（毕竟是要获得子线程返回的结果，所以必须得等子线程结束才行）