1、多线程的概述
什么是线程？
-
线程(thread)是一个程序内部的一条执行路径。
-
我们之前启动程序执行后，main方法的执行其实就是一条单独的执行路径。
public static void main(String[] args) { // 代码... for (int i = 0; i < 10; i++) { System.out.println(i); } // 代码... } -
程序中如果只有一条执行路径，那么这个程序就是单线程的程序。
多线程是什么？
- 多线程是指从软硬件上实现多条执行流程的技术。
- 12306、百度云盘、微信、淘宝、京东系统都离不开多线程技术。
2、多线程的创建
2.1、继承Thread类
- Java是通过java.lang.Thread 类来代表线程的。
- 按照面向对象的思想，Thread类应该提供了实现多线程的方式。
- 定义一个子类MyThread继承线程类java.lang.Thread，重写run()方法
- 创建MyThread类的对象
- 调用线程对象的start()方法启动线程（启动后还是执行run方法的）
代码演示
class MyThread extends Thread{
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println("子线程执行输出: " + i);
}
}
}
public class TestThread {
public static void main(String[] args) {
Thread t = new MyThread();
t.start();
for (int i = 0; i < 5; i++) {
System.out.println("主线程执行输出: " + i);
}
}
}
输出结果
主线程执行输出: 0
子线程执行输出: 0
子线程执行输出: 1
主线程执行输出: 1
主线程执行输出: 2
主线程执行输出: 3
子线程执行输出: 2
主线程执行输出: 4
子线程执行输出: 3
子线程执行输出: 4
- 优点：编码简单
- 缺点：线程类已经继承Thread，无法继承其他类，不利于扩展。
注意事项
1、为什么不直接调用了run方法，而是调用start启动线程？
- 直接调用run方法会当成普通方法执行，此时相当于还是单线程执行。
- 只有调用start方法才是启动一个新的线程执行。
2、如果把主线程任务放在子线程之前会怎么样？
- 这样主线程一直是先跑完的，相当于是一个单线程的效果了。
代码演示
class MyThread extends Thread{
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println("子线程执行输出: " + i);
}
}
}
public class TestThread {
public static void main(String[] args) {
for (int i = 0; i < 5; i++) {
System.out.println("主线程执行输出: " + i);
}
Thread t = new MyThread();
t.start();
}
}
输出结果
主线程执行输出: 0
主线程执行输出: 1
主线程执行输出: 2
主线程执行输出: 3
主线程执行输出: 4
子线程执行输出: 0
子线程执行输出: 1
子线程执行输出: 2
子线程执行输出: 3
子线程执行输出: 4
补充
其实Thread类是通过继承Runnable接口并重写里面的run方法实现创建多线程的
后续会介绍如何通过实现Runnable接口创建多线程
2.2、实现Runnable接口
- 定义一个线程任务类MyRunnable实现Runnable接口，重写run()方法
- 创建MyRunnable任务对象
- 把MyRunnable任务对象交给Thread处理
- 调用线程对象的start()方法启动线程
Thread构造器
| Thread构造器 | 说明 |
|---|---|
| public Thread(String name) | 指定线程名称 |
| public Thread(Runnable target) | 封装Runnable对象成为线程对象 |
| public Thread(Runnable target ，String name) | 封装Runnable对象成为线程对象，并指定线程名称 |
代码演示
class MyRunnable implements Runnable{
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println("子线程执行输出: " + i);
}
}
}
public class TestRunnable {
public static void main(String[] args) {
Runnable target = new MyRunnable();
// 使用 public Thread(Runnable target) 构造器
// 封装 Runnable 对象成为线程对象
Thread t = new Thread(target);
t.start();
for (int i = 0; i < 5; i++) {
System.out.println("主线程执行输出: " + i);
}
}
}
输出结果
主线程执行输出: 0
主线程执行输出: 1
子线程执行输出: 0
子线程执行输出: 1
主线程执行输出: 2
主线程执行输出: 3
子线程执行输出: 2
主线程执行输出: 4
子线程执行输出: 3
子线程执行输出: 4
- 优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强。
- 缺点：编程多一层对象包装，如果线程有执行结果是不可以直接返回的。
匿名内部类方式创建
本质上与上述方法的创建方式相同，只是利用匿名内部类方式简化代码
代码演示
public class TestRunnableInnerClass {
public static void main(String[] args) {
Runnable target = new Runnable() {
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println("子线程1执行输出: " + i);
}
}
};
Thread t = new Thread(target);
t.start();
// 使用Lambda表达式简化代码
Runnable targetByLambda = () -> {
for (int i = 0; i < 5; i++) {
System.out.println("子线程2执行输出: " + i);
}
};
Thread tByLambda = new Thread(targetByLambda);
tByLambda.start();
// 最终代码可以简化为
new Thread(() -> {
for (int i = 0; i < 5; i++) {
System.out.println("子线程3执行输出: " + i);
}
}).start();
for (int i = 0; i < 5; i++) {
System.out.println("主线程执行输出: " + i);
}
}
}
输出结果
子线程3执行输出: 0
子线程3执行输出: 1
主线程执行输出: 0
子线程1执行输出: 0
主线程执行输出: 1
主线程执行输出: 2
子线程3执行输出: 2
子线程2执行输出: 0
主线程执行输出: 3
子线程1执行输出: 1
主线程执行输出: 4
子线程2执行输出: 1
子线程3执行输出: 3
子线程2执行输出: 2
子线程1执行输出: 2
子线程2执行输出: 3
子线程3执行输出: 4
子线程2执行输出: 4
子线程1执行输出: 3
子线程1执行输出: 4
2.3、实现Callable接口
为什么JDK要在5.0版本新增实现Callable接口创建多线程功能？
前两种创建多线程的方式均不能直接返回结果，不适合需要返回线程执行结果的业务场景。
实现方式
- 得到任务对象。
- 定义类实现Callable接口，重写call方法，封装要做的事情。
- 用FutureTask把Callable对象封装成线程任务对象。
- 把线程任务对象交给Thread处理。
- 调用Thread的start方法启动线程，执行任务。
- 线程执行完毕后、通过FutureTask的get方法去获取任务执行的结果。
FutureTask API
| 方法名称 | 说明 |
|---|---|
| public FutureTask(Callable callable) | 构造方法：把Callable对象封装成FutureTask对象 |
| public V get() throws Exception | 获取线程执行call方法返回的结果。 |
代码演示
public class TestCallable {
public static void main(String[] args) {
Callable<String> call1 = new MyCallable(100);
FutureTask<String> f1 = new FutureTask<>(call1);
Thread t1 = new Thread(f1);
t1.start();
Callable<String> call2 = new MyCallable(200);
FutureTask<String> f2 = new FutureTask<>(call2);
Thread t2 = new Thread(f2);
t2.start();
try {
// 如果f1任务没有执行完毕，这里的代码会等待，直到线程1跑完才提取结果。
String rs1 = f1.get();
System.out.println("第一个结果：" + rs1);
} catch (Exception e) {
e.printStackTrace();
}
try {
// 如果f2任务没有执行完毕，这里的代码会等待，直到线程2跑完才提取结果。
String rs2 = f2.get();
System.out.println("第二个结果：" + rs2);
} catch (Exception e) {
e.printStackTrace();
}
}
}
class MyCallable implements Callable<String> {
private final int n;
public MyCallable(int n) {
this.n = n;
}
@Override
public String call() {
int sum = 0;
for (int i = 1; i <= n ; i++) {
sum += i;
}
return "子线程执行的结果是：" + sum;
}
}
输出结果
第一个结果：子线程执行的结果是：5050
第二个结果：子线程执行的结果是：20100
补充
Thread t1 = new Thread(f1);中为什么Thread类构造器可以传入FutureTask<>对象？
通过IDEA点入可以查看到执行的构造器为public Thread(Runnable target) {}，需要传入的是Runnable对象
我们可以看到FutureTask<>类实现了RunnableFuture<V>接口
最后会发现RunnableFuture<V>接口原来是继承了Runnable接口，所以也就解释了为什么Thread类构造器可以传入FutureTask<>对象
3、三种创建多线程的方式对比
| 方式 | 优点 | 缺点 |
|---|---|---|
| 继承Thread类 | 编程比较简单，可以直接使用Thread类中的方法 | 扩展性较差，不能再继承其他的类，不能返回线程执行的结果 |
| 实现Runnable接口 | 扩展性强，实现该接口的同时还可以继承其他的类 | 编程相对复杂，不能返回线程执行的结果 |
| 实现Callable接口 | 扩展性强，实现该接口的同时还可以继承其他的类，可以得到线程执行的结果 | 编程相对复杂 |
