文章目录

• 多线程
• • 多线程简介
  • 多线程创建
  • • 方式一: 继承Thread类
    • 方式二: 实现Runnable接口
    • 方式三: 实现Callable接口

多线程

多线程简介

什么是线程?

线程(thread)是一个程序内部的一条执行路径。

我们之前启动程序执行后，main方法的执行其实就是一条单独的执行路径。

public static void main(String[] args) {
  	// 代码...
  	for (int i = 0; i < 10; i++) {
      	System.out.println(i);
		}
  	// 代码...
}

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

什么是多线程?

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

多线程创建

方式一: 继承Thread类

Thread类:

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

按照面向对象的思想，Thread类应该提供了实现多线程的方式。

Thread类创建线程方式:

1. 定义一个子类MyThread继承线程类java.lang.Thread
2. 子类MyThread中重写run()方法
3. 创建MyThread类的实例对象
4. 调用子线程对象的start()方法启动线程（启动后还是执行run方法的）

Thread类创建多线程示例代码如下:

public class ThreadDemo {
    public static void main(String[] args) {
        // 3. 创建MyThread类的实例对象
        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方法, run方法中定义创建出来的线程要做什么
     */
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程执行输出: " + i);
        }
    }
}

Thread类创建多线程的有缺点:

优点：编码简单

缺点：线程类已经继承Thread，无法继承其他类，不利于扩展; 如果线程有执行结果是不可以直接返回的, 意思是重写的run方法如果是有返回值是没办法获取到的, 该方式只适合执行功能。

上面提到, 调用start方法启动后还是执行的run方法, 那么为什么不直接执行run方法呢?

直接调用run方法会当成普通方法执行，此时相当于还是单线程执行。

只有调用start方法才是启动一个新的线程执行。

注意: 不要把主线程执行任务的代码放在子线程之前, 因为这样做主线程一直是先跑完的才开启子线程，相当于是一个单线程的效果了。

方式二: 实现Runnable接口

通过实现Runnable接口创建多线程方式如下:

1. 定义一个线程任务类MyRunnable实现Runnable接口
2. 任务类MyRunnable中重写run()方法
3. 创建MyRunnable任务类对象
4. 把MyRunnable任务对象交给Thread处理。
5. 调用线程对象的start()方法启动线

实现Runnable接口创建多线程示例代码:

public class ThreadDemo2 {
    public static void main(String[] args) {
        // 3. 创建MyRunnable 任务对象
        Runnable target = new MyRunnable();
        // 4. 把任务对象交给线程对象(Thread)处理
        Thread t = new Thread(target);
        // 5. 启动线程
        t.start();

        // 主线程要执行的操作
        for (int i = 0; i < 5; i++) {
            System.out.println("主线程执行输出: " + i);
        }
    }
}

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

实现Runnable接口创建多线程, 匿名内部类的方式简化方式一:

public static void main(String[] args) {
    // 1. 创建任务对象(匿名内部类的方式)
    Runnable target = new Runnable() {
        @Override
        public void run() {
            for (int i = 0; i < 5; i++) {
                System.out.println("子线程执行输出: " + i);
            }
        }
    };
    // 2. 将任务对象交给线程对象(Thread)处理
    Thread t = new Thread(target);
    // 3. 启动线程
    t.start();

    // 主线程执行的操作
    for (int i = 0; i < 5; i++) {
        System.out.println("主线程执行输出: " + i);
    }
}

实现Runnable接口创建多线程, 匿名内部类的方式简化方式二:

public static void main(String[] args) {
    // 1. 创建任务对象(匿名内部类的方式)
    // 2. 将任务对象交给线程对象(Thread)处理
    // 3. 启动线程
    new Thread(new Runnable() {
        @Override
        public void run() {
            for (int i = 0; i < 5; i++) {
                System.out.println("子线程执行输出: " + i);
            }
        }
    }).start();

    // 主线程执行的操作
    for (int i = 0; i < 5; i++) {
        System.out.println("主线程执行输出: " + i);
    }
}

实现Runnable接口创建多线程, 匿名内部类结合Lambda表达式的方式简化方式三:

public static void main(String[] args) {
    // 1. 创建任务对象(匿名内部类的方式)
    // 2. 将任务对象交给线程对象(Thread)处理
    // 3. 启动线程
    new Thread(() -> {
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程执行输出: " + i);
        }
    }).start();

    // 主线程执行的操作
    for (int i = 0; i < 5; i++) {
        System.out.println("主线程执行输出: " + i);
    }
}

实现Runnable接口创建多线程的优缺点:

优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强。

缺点：编程多一层对象包装，如果线程有执行结果是拿不到返回结果的。

方式三: 实现Callable接口

前两种线程创建方式都存在一个问题:

他们重写的run方法均不能直接返回结果。

不适合需要返回线程执行结果的业务场景。

那么如何解决这个问题呢?

JDK 5.0提供了Callable和FutureTask结合使用来实现多线程。

这种实现多线程方式的优点是：可以得到线程执行的结果。

多线程的实现方案三：利用Callable、FutureTask接口实现, 实现步骤如下:

① 得到任务对象

• 定义类实现Callable接口，重写call方法，call方法中封装我们要做的事情, 并且call方法是可以返回结果的。
• 把Callable任务对象交给FutureTask封装成线程任务对象。

② 把线程任务对象交给线程对象(Thread)处理。

③ 调用Thread的start方法启动线程，执行任务

④ 线程执行完毕后、通过FutureTask的get方法去获取任务执行的结果。

使用FutureTask包装的作用:

作用一: Thread线程对象构造器只接受Runnable类型的对象, FutureTask是实现了Runnable接口的, 可以交给Thread处理

作用二: 可以在线程执行完毕之后通过调用其get方法得到线程执行完成的结果

FutureTask的API

方法名称	说明
FutureTask<>(Callable call)	把Callable对象封装成FutureTask对象。
get() throws Exception	获取线程执行call方法返回的结果。

演示代码

public class ThreadDemo4 {
    public static void main(String[] args) {
        // 3. 创建任务对象
        Callable<String> callable  = new MyCallable(5);

        // 4. 将任务对象包装成线程任务对象
        FutureTask<String> ft = new FutureTask<>(callable);

        // 5. 将线程任务对象交给线程对象(Thread)处理
        Thread t = new Thread(ft);

        // 6. 启动线程
        t.start();

        // 获取线程执行的结果, 会返回正常的结果和异常的结果
        try {
            String res = ft.get();
            System.out.println(res);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

/**
    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 "子线程方法执行的结果是" + sum;
    }
}

方式三的优缺点:

优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强。

可以在线程执行完毕后去获取线程执行的结果。

缺点：编码会显得复杂一点。

总结: 三种方式对比如下

方式	优点	缺点
继承Thread类	编程比较简单，可以直接使用Thread类中的方法	扩展性较差，不能再继承其他的类，不能返回线程执行的结果
实现Runnable接口	扩展性强，实现该接口的同时还可以继承其他的类。	编程相对复杂，不能返回线程执行的结果
实现Callable接口	扩展性强，实现该接口的同时还可以继承其他的类。可以得到线程执行的结果	编程相对复杂