什么是线程?
- 线程(thread)是一个程序内部的一条执行路径。
- 我们之前启动程序执行后,main方法的执行其实就是一条单独的执行路径。
- 程序中如果只有一条执行路径,那么这个程序就是单线程的程序。
多线程是什么?
- 多线程是指从软硬件上实现多条执行流程的技术。
- 在很多地方都离不开多线程的使用,例如某宝,狗东等。
Thread类
- Java是通过java.lang.Thread 类来代表线程的。
- 按照面向对象的思想,Thread类应该提供了实现多线程的方式。
多线程的实现方案一:继承Thread类
- 定义一个子类MyThread继承线程类java.lang.Thread,重写run0方法
- 创建MyThread类的对象
- 调用线程对象的start(方法启动线程(启动后还是执行run方法的)
方式一优缺点:
- 优点:编码简单
- 缺点:线程类已经继承Thread,无法继承其他类,不利于扩展。
代码演示如下:
public class ThreadDemo01 { 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); } } }
1.为什么不直接调用run方法,而是调用start启动线程?
- 直接调用run方法会当成普通方法执行,此时相当于还是单线程执行。
- 只有调用start方法才是启动一个新的线程执行。
2.为什么要把主线程任务放在子线程后面?
- 这样主线程一直是先跑完的,相当于是一个单线程的效果了。
多线程的实现方案二:实现Runnable接口
- 定义一个线程任务类MyRunnable实现Runnable接口,重写run(方法
- 创建MyRunnable任务对象
- 把MyRunnable任务对象交给Thread处理。
- 调用线程对象的start()方法启动线程
代码演示如下:
public class ThreadDemo02 { public static void main(String[] args) { //3.创建一个任务对象 Runnable target = new MyRunnable(); //4.把任务对象交给Thread处理 Thread t = new Thread(target); //5.启动线程 t.start(); for (int i = 0; i < 10;i++){ System.out.println("主线程执行输出:" + i); } } } /** 1.定义一个线程任务类 实现Runnable接口 */ class MyRunnable implements Runnable{ @Override public void run() { for (int i = 0; i < 10; i++){ System.out.println("子线程执行输出:" + i); } } }
方式二的优点:
- 优点:线程任务类只是实现了Runnale接口,可以继续继承和实现。
- 缺点:如果线程有执行结果是不能直接返回的。
实现Runnable接口(匿名内部类形式)
- 可以创建Runnable的匿名内部类对象。
- 交给Thread处理。
- 调用线程对象的start()启动线程。
代码演示如下:
public class ThreadDemo02Other { public static void main(String[] args) { //3.创建一个任务对象 Runnable target = new MyRunnable() { @Override public void run() { for (int i = 0; i < 10; i++) { System.out.println("子线程1执行输出:" + i); } } }; //4.把任务对象交给Thread处理 Thread t = new Thread(target); //5.启动线程 t.start(); for (int i = 0; i < 10; i++) { System.out.println("主线程执行输出:" + i); } new Thread(new Thread() { @Override public void run() { for (int i = 0; i < 10; i++) { System.out.println("子线程2执行输出:" + i); } } }).start(); new Thread(() ->{ for (int i = 0; i < 10; i++) { System.out.println("子线程3执行输出:" + i); } }).start(); } }
1.前2种线程创建方式都存在一个问题:
- 他们重写的run方法均不能直接返回结果。
- 不适合需要返回线程执行结果的业务场景。
2.怎么解决这个问题呢?
- JDK 5.0提供了Callable和FutureTask来实现。
- 这种方式的优点是:可以得到线程执行的结果。
多线程的实现方案三:利用Callable、FutureTask接口实现
- 得到任务对象
- 定义类实现Callable接口,重写call方法,封装要做的事情。
- 用FutureTask把callable对象封装成线程任务对象。
- 把线程任务对象交给Thread处理。
- 调用Thread的start方法启动线程,执行任务
- 线程执行完毕后、通过FutureTask的get方法去获取任务执行的结果。
代码演示如下:
public class ThreadDemo3 { public static void main(String[] args) throws ExecutionException, InterruptedException { //3.创建Callable任务对象 Callable<String> call = new MyRunnable(100); //4.把Callable任务对象 交给FutureTask 对象 // FutureTask对象的作用1: 是Runnable的对象(实现了Runnable接口) // FutureTask对象的作用2: 可以在线程执行完毕之后通过调用其get方法得到线程执行完成的结果 FutureTask<String> f1 = new FutureTask<>(call); //5.交给线程处理 Thread t1 = new Thread(f1); //6.启动线程 t1.start(); Callable<String> call2 = new MyRunnable(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(); } } /** * 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 = 0; i <= n; i++) { sum += i; } return "子线程执行的结果是:" + sum; } } }
FutureTask的API
方法三优缺点:
- 优点:线程任务类只是实现接口,可以继续继承类和实现接口,扩展性强。
- 可以在线程执行完牛后去获取线程执行的结果。
- 缺点:编码复杂一点。
三种方式对比
Thread提供的线程操作相关的方法
代码演示如下:
public class Mythread extends Thread{ public Mythread(String name){ super(name); // 为当前线程设置名字 } @Override public void run(){ // 哪个线程执行它,它就会得到哪个线程对象 Thread t = Thread.currentThread(); for (int i = 0; i <= 3; i++) { System.out.println(t.getName() + "输出:" + i); } } }
public class ThreadTest1 { public static void main(String[] args) { Thread t1 = new Mythread("1号线程"); t1.start(); System.out.println(t1.getName()); Thread t2 = new Mythread("2号线程"); t2.start(); System.out.println(t2.getName()); Thread m = Thread.currentThread(); m.setName("最牛的线程"); System.out.println(m.getName()); for (int i = 0; i <= 5; i++) { System.out.println(m.getName() + "线程输出:" + i); } } }
public class ThreadTest2 { public static void main(String[] args) throws Exception { for (int i = 0; i <= 5; i++) { System.out.println(i); //休眠5秒 if (i == 3) { // 会让当前执行的线程暂停5秒,再继续执行 // 项目经理让我加上这行代码,如果用户交钱了,我就注释掉! Thread.sleep(5000); } } // join方法作用:让当前调用这个方法的线程先执行完 Thread t1 = new Mythread("1号线程"); t1.start(); t1.join(); Thread t2 = new Mythread("2号线程"); t2.start(); t2.join(); Thread t3 = new Mythread("3号线程"); t3.start(); t3.join(); } }