Java多线程基础

一、线程概述

1.1 什么是线程

• 线程（thread）是一个程序内部的一条执行路径。
• main方法的执行是一条单独的执行路径。
• 程序中如果只有一条执行路径，那么这个程序就是单线程的程序。

1.2 什么是多线程

• 多线程是指从软硬件上实现多条执行流程的技术。

二、多线程的创建

2.1 继承Thread类

• Java是通过java.lang.Thread类来代表线程的。
• 按照面向对象的思想，Thread类提供了实现多线程的方式。
• 过程：
  1. 定义一个子类MyThread继承线程类java.lang.Thread，重写run()方法
  2. 创建MyThread类的对象
  3. 调用线程对象的start()方法启动线程（启动后还是执行run方法）
• 优点：编码简单
• 缺点：线程类已经继承Thread类，无法继承其他类，不利于扩展
• 为什么不调用run方法，而是调用start？
  • 直接调用run方法会当成普通方法执行，此时相当于还是单线程执行。
  • 只有调用start方法才是启动一个新的线程执行。
• 主线程任务应该放在子线程之后。

/**
 * 多线程的创建方式一：继承Thread类
 */
public class ThreadDemo1 {
   
    public static void main(String[] args) {
   
        //3.new一个新线程对象
        Thread t = new MyThread();
        //4.调用start方法启动线程（执行run）
        t.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);
        }
    }
}

2.2 实现Runnable接口

• 过程：
  1. 定义一个线程任务类MyRunnable实现Runnable接口，重写run()方法。
  2. 创建MyRunnable任务对象。
  3. 把MyRunnable任务对象交给Thread处理。
  4. 调用线程对象的start()方法启动线程。
• 优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强。
• 缺点：编程多一层对象包装，如果线程有执行结果是不可以直接返回的。

/**
 * 多线程的创建方式二：实现Runnable接口
 */
public class ThreadDemo2 {
   
    public static void main(String[] args) {
   
        //3.创建一个任务对象
        MyRunnable task = new MyRunnable();
        //4.将任务对象交给线程对象Thread处理
        Thread t = new Thread(task);
        //5.启动线程
        t.start();
        for (int i = 0; i < 10; i++) {
   
            System.out.println("主线程输出：" + i);
        }
    }
}
//1.定义一个线程类，实现Runnable接口
class MyRunnable implements Runnable {
   
    //2.重写run方法，定义线程任务
    @Override
    public void run() {
   
        for (int i = 0; i < 10; i++) {
   
            System.out.println("子线程输出：" + i);
        }
    }
}

2.3 实现Callable接口

• 前2种线程创建方式都存在一个问题：
  • 他们重写的run方法均不能直接返回结果
  • 不适合需要返回线程执行结果的业务场景
• 过程
  1. 得到任务对象
     1. 定义类实现Callable接口，重写call方法，封装要做的事情
     2. 用FutureTask把Callable对象封装成线程任务对象
  2. 把线程任务对象交给Thread处理
  3. 调用Thread的start方法启动线程，执行任务
  4. 线程执行完毕后，通过FutureTask的get方法去获取任务执行的结果
• FutureTask
  • public FutureTask<>(Callable call)：把Callable对象封装成FutureTask对象
  • public V get()：获取线程执行call方法返回结果
• 优点：
  • 线程任务类只是实现接口，可以继续继承类的实现接口，扩展性强
  • 可以在线程执行完毕后去获取线程执行的结果
• 缺点：编码稍微复杂

/**
 * 多线程的创建方式三：实现Callable接口，结合FutureTask完成。
 */
public class threadDemo3 {
   
    public static void main(String[] args) {
   
        //3.创建Callable任务对象
        Callable call1 = new MyCallable(100);
        //4.把Callable任务对象，交给FutureTask对象(实现了Runnable接口，可以调用get方法得到线程执行结果)
        FutureTask<String> f1 = new FutureTask<String>(call1);
        //5.交给线程执行
        Thread t1 = new Thread(f1);
        //6.启动线程
        t1.start();
        //3.创建Callable任务对象
        Callable call2 = new MyCallable(200);
        //4.把Callable任务对象，交给FutureTask对象(实现了Runnable接口，可以调用get方法得到线程执行结果)
        FutureTask<String> f2 = new FutureTask<String>(call2);
        //5.交给线程执行
        Thread t2 = new Thread(f2);
        //6.启动线程
        t2.start();
        try {
   
            String rs1 = f1.get();
            System.out.println("第一个线程执行结果: " + rs1);
        } catch (InterruptedException e) {
   
            e.printStackTrace();
        } catch (ExecutionException e) {
   
            e.printStackTrace();
        }
        try {
   
            String rs2 = f2.get();
            System.out.println("第二个线