文章目录
- 多线程
- 多线程简介
- 多线程创建
- 方式一: 继承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类创建线程方式:
- 定义一个子类MyThread继承线程类java.lang.Thread
- 子类MyThread中重写run()方法
- 创建MyThread类的实例对象
- 调用子线程对象的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方法中定义创建出来的线程要做什么 */@Overridepublic void run() {for (int i = 0; i < 5; i++) {System.out.println("子线程执行输出: " + i);}}}
Thread类创建多线程的有缺点:
优点:编码简单
缺点:线程类已经继承Thread,无法继承其他类,不利于扩展; 如果线程有执行结果是不可以直接返回的, 意思是重写的run方法如果是有返回值是没办法获取到的, 该方式只适合执行功能。
上面提到, 调用start方法启动后还是执行的run方法, 那么为什么不直接执行run方法呢?
直接调用run方法会当成普通方法执行,此时相当于还是单线程执行。
只有调用start方法才是启动一个新的线程执行。
注意: 不要把主线程执行任务的代码放在子线程之前, 因为这样做主线程一直是先跑完的才开启子线程,相当于是一个单线程的效果了。
方式二: 实现Runnable接口
通过实现Runnable接口创建多线程方式如下:
- 定义一个线程任务类MyRunnable实现Runnable接口
- 任务类MyRunnable中重写run()方法
- 创建MyRunnable任务类对象
- 把MyRunnable任务对象交给Thread处理。
- 调用线程对象的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方法 */@Overridepublic 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() {@Overridepublic 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() {@Overridepublic 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方法(任务方法) */@Overridepublic String call() throws Exception {int sum = 0;for (int i = 1; i <= n ; i++) {sum += i;}return "子线程方法执行的结果是" + sum;}}
方式三的优缺点:
优点:线程任务类只是实现接口,可以继续继承类和实现接口,扩展性强。
可以在线程执行完毕后去获取线程执行的结果。
缺点:编码会显得复杂一点。
总结: 三种方式对比如下
方式 | 优点 | 缺点 |
---|---|---|
继承Thread类 | 编程比较简单,可以直接使用Thread类中的方法 | 扩展性较差,不能再继承其他的类,不能返回线程执行的结果 |
实现Runnable接口 | 扩展性强,实现该接口的同时还可以继承其他的类。 | 编程相对复杂,不能返回线程执行的结果 |
实现Callable接口 | 扩展性强,实现该接口的同时还可以继承其他的类。可以得到线程执行的结果 | 编程相对复杂 |