什么是线程？
线程（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方法
@Override
public 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方法
@Override
public 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() {
@Override
public 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() {
@Override
public 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方法
@Override
public 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-0
Thread 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); //为当前线程设置名字
}
@Override
public 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);
// 休眠5s
if (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();
}
}四. 线程安全问题
什么是线程安全问题？
多个线程，同时操作同一个共享资源的时候，可能会出现业务安全问题。
用程序模拟线程安全问题
1
