JAVA基础｜多线程

什么是线程？

线程（Thread）是一个程序内部的一条执行流程。

多线程是什么？

多线程是指从软硬件上实现的多条执行流程的技术（多条线程由CPU负责调度执行）

一. 如何在程序中创建出多条线程？

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

1. 多线程的创建方式一：继承Thread类

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

ThreadTest1.java：

public class ThreadTest {// main方法是由一条默认的主线程负责执行的。public static void main(String[] args) {// 3. 创建Mythread线程类的对象代表一个线程Thread t = new MyThread();// 4. 启动线程（自动执行run方法的）t.start();  // main线程 t线程for (int i = 1; i <= 5; i++) {System.out.println("主线程main输出: " + i);}}
}

MyThread.java：

//1. 让子类继承Thread线程类
public class MyThread extends Thread{// 2. 必须重写Thread类的run方法@Overridepublic void run() {for (int i = 1; i <= 5; i++) {System.out.println("子线程MyThread线程输出： " + i);}}
}

方式一的优缺点：

优点：编码简单
缺点：线程类已经继承Thread，无法继承其他类，不利于功能的扩展。

2. 多线程的创建方式二：实现Runnable接口

定义一个线程任务类MyRunnable实现Runnable接口，重写run()方法
创建MyRunnable任务对象
把MyRunnable任务对象交给Thread处理（因为任务对象不是线程对象，不能调用start方法，所以要将他封装为线程对象）使用Thread自带的构造器来做。
调用线程对象的start()方法启动线程

ThreadTest.java

public class ThreadTest {public static void main(String[] args) {// 3. 创建任务对象Runnable target = new MyRunnable();// 4. 把任务对象交给一个线程对象处理// public Thread(Runnable target)new Thread(target).start();for (int i = 0; i <= 5; i++) {System.out.println("主线程main输出 ===> " + i);}}
}

MyRunnable.java:

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

方式二的优缺点：

优点：任务类只是实现接口，可以继续继承其他类，实现其他接口，扩展性能
缺点：需要多创建一个Runnable对象（其实也不算啥缺点。。）

方法二的匿名内部类写法：

可以创建Runnable的匿名内部类对象
再交给Thread线程对象
再调用线程对象的start()启动线程

public class ThreadTest2_2 {public static void main(String[] args) {// 1. 直接创建Runnable接口的匿名内部类形式（任务对象）Runnable target = new Runnable() {@Overridepublic void run() {for (int i = 0; i <= 5; i++) {System.out.println("子线程1输出： " + i);}}};new Thread(target).start();for (int i = 0; i <= 5; i++) {System.out.println("主线程main输出： " + i);}}
}

简化：

//简化形式1: new Thread(new Runnable() {@Overridepublic void run() {for (int i = 0; i <= 5; i++) {System.out.println("子线程1输出： " + i);}}}).start();//简化形式2:new Thread(() -> {for (int i = 0; i <= 5; i++) {System.out.println("子线程1输出： " + i);}}).start();

3. 多线程的创建方式三：实现Callable接口，利用FutureTask类

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

假如线程执行完毕后有一些数据需要返回，他们重写的run方法均不能直接返回结果。

怎么解决这个这个问题呢？

JDK 5.0 提供了Callable接口和FutureTask类来实现（多线程的第三种创建方式）
这种方式最大的优点：可以返回线程执行完毕后的结果。

创建方法：

创建任务对象
定义一个类实现Callable接口，重写call方法，封装要做的事情和要返回的数据
把Callable类型的对象封装成FutureTask（线程任务对象）
把线程任务对象交给Thread对象
调用Thread对象的start方法启动线程
线程执行完毕后，通过FutureTask对象的get方法去获取线程任务执行的结果

ThreadTest.java:

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;public class ThreadTest3 {public static void main(String[] args) throws Exception {// 3. 创建一个Callable的对象Callable<String> call = new MyCallable(100);// 4. 把Callable的对象封装成一个FutureTask对象（任务对象）// 未来任务对象的作用？// 1. 是一个任务对象，实现了Runnable对象// 2. 可以在线程执行完毕之后，用未来任务对象调用get方法获取线程执行完毕后的结果FutureTask<String> f1 = new FutureTask<>(call);// 5. 把任务对象交给一个Thread对象new Thread(f1).start();Callable<String> call2 = new MyCallable(100);FutureTask<String> f2 = new FutureTask<>(call2);new Thread(f2).start();// 6. 获取线程执行完毕后返回的结果// 注意：如果执行到这，假如上面的线程还没有执行完毕// 这里的代码会暂停，等待上面线程执行完毕后才会获取结果String rs = f1.get();System.out.println(rs);String rs2 = f2.get();System.out.println(rs2);T}
}

MyCallable.java:

import java.util.concurrent.Callable;// 1. 实现Callable接口
public class MyCallable implements Callable<String> {private int n;public MyCallable(int n) {this.n = n;}// 2. 重写call方法@Overridepublic String call() throws Exception {// 描述线程的任务，返回线程执行返回后的结果// 需求： 求1-n的和返回int sum = 0;for (int i = 0; i <= n; i++) {sum += i;}return "线程求出了1-" + n + "的和是：" + sum;}
}

方式三的优缺点：

优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强；可以在线程执行完毕后去获取线程执行的结果
缺点：编码复杂一点

二. 多线程的注意事项

启动线程必须是调用start方法，不是调用run方法：使用run的话相当于调用了MyThread对象中的run方法，这样就仍然是单线程。
不要把主线程任务放在启动子线程之前：这样的话主线程一直是先跑完的，相当于是一个单线程的效果了。

三. Thread的常用方法

获取当前线程的名字，设置线程名字：

ThreadTest.java:

public class ThreadTest {public static void main(String[] args) {Thread t1 = new MyThread("1号线程");/*t1.setName("1号线程");*/t1.start();System.out.println(t1.getName());   //Thread-0Thread t2 = new MyThread("2号线程");/*t2.setName("2号线程");*/t2.start();System.out.println(t2.getName());   //Thread-1//主线程对象的名字//哪个线程执行他，他就会得到哪个线程对象Thread m = Thread.currentThread();System.out.println(m.getName());for (int i = 0; i <= 5; i++) {System.out.println("main线程输出： " + i);}}
}

MyThread.java:

public class MyThread extends Thread {public MyThread(String name) {super(name);    //为当前线程设置名字}@Overridepublic void run() {Thread t = Thread.currentThread();for (int i = 0; i <= 3; i++) {System.out.println(t.getName()+ "输出: " + i);}}
}

sleep,join方法

public class ThreadTest2 {public static void main(String[] args) throws Exception{for (int i = 0; i <= 5; i++) {System.out.println(i);// 休眠5sif (i ==3) {//会让当前执行的线程暂停5秒，再继续执行//项目经历让我加上这行代码，如果用户交钱了，我就注释掉！ 「Doge」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();}
}