1 什么是进程？
通俗地解释为：计算机中正在执行的一个程序实例。进程它是系统分配资源的基本单位。
想象一下，你的电脑就像是一个大工厂，而每一个进程就像是这个工厂里的一条生产线或者一个工作小组，它们各自独立地运行着不同的任务，但同时又受到整个工厂（即操作系统）的管理和调度。
2 什么是线程？
线程（Thread）是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位。一个进程可以拥有多个线程，这些线程共享该进程的地址空间和系统资源，但各自拥有独立的执行栈和程序计数器，以便能够独立地执行指令序列。
我们原来写的代码都是单线程。
3 为什么实现多线程？
3.1 进程与线程的关系
可以想象一个工厂代表一个进程，而工厂内的工人则代表进程中的线程。
+------------------------+
| 工厂 | <-- 进程
| (操作系统分配的资源) |
| +-----+-----+-----+ |
| |工人1|工人2|工人3| | <-- 线程
| +-----+-----+-----+ |
| ... |
| +-----+-----+-----+ |
| |工人N|空闲位置|空闲位置| <-- 更多线程或可扩展性
| +-----+-----+-----+ |
+------------------------+
在这个模型中，每个工人（线程）都在工厂（进程）内独立工作，但他们共享工厂的资源（如工具、原材料等），这些资源相当于进程中的内存、文件句柄等。
3.2 多线程的优势
提高CPU利用率：
+------------------------+
| 工厂 |
| (CPU核心) |
| +-----+-----+-----+ |
| | CPU1| CPU2| CPU3| | <-- 多核CPU
| +-----+-----+-----+ |
| |工人1|工人2|工人3| | <-- 每个CPU核心运行一个线程
| +-----+-----+-----+ |
+------------------------+
在多核CPU上，每个核心可以独立运行一个线程，从而提高了CPU的利用率。当某个线程等待I/O操作时，CPU可以切换到另一个线程继续工作
4 java中如何创建多线程
java中提供了三种实现多线程的方式:
第一种: 继承Thread类
第二种: 实现Runnable接口
第三种: 实现Callable接口
4.1继承Thread类
这是创建线程的最基本方式之一。通过继承Thread类并重写其run()方法，你可以定义线程执行的任务。然后，创建该类的实例并调用其start()方法来启动线程。
// 继承Thread类
class MyThread extends Thread {
@Override
public void run() {
// 在这里编写线程要执行的任务
System.out.println("线程运行中：" + Thread.currentThread().getName());
}
}
public class ThreadExample {
public static void main(String[] args) {
MyThread t1 = new MyThread();
t1.start(); // 启动线程
}
}
4.2 实现Runnable接口
实现Runnable接口是另一种创建线程的方式。这种方式相比继承Thread类更加灵活，因为Java不支持多重继承，但可以实现多个接口。通过实现Runnable接口，你可以将线程的任务与线程的实现分离。然后，创建Thread类的实例，将实现了Runnable接口的类的实例作为构造器参数传递。
// 实现Runnable接口
class MyRunnable implements Runnable {
@Override
public void run() {
// 在这里编写线程要执行的任务
System.out.println("线程运行中：" + Thread.currentThread().getName());
}
}
public class RunnableExample {
public static void main(String[] args) {
Thread t1 = new Thread(new MyRunnable());
t1.start(); // 启动线程
}
}
4.3实现Callable接口
Callable接口是Java 5中引入的，与Runnable接口类似，但它可以返回一个结果，并且可以抛出异常。要实现Callable接口，你需要创建一个实现了该接口的类，并实现其call()方法。然而，你不能直接通过Callable接口来启动线程，因为Thread类并不接受Callable作为构造器参数。相反，你需要使用FutureTask类来包装Callable对象，FutureTask同时实现了Future和Runnable接口。然后，你可以像使用Runnable一样，通过Thread来执行FutureTask。
// 实现Callable接口
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
class MyCallable implements Callable<String> {
@Override
public String call() throws Exception {
// 在这里编写线程要执行的任务
return "线程运行结果";
}
}
public class CallableExample {
public static void main(String[] args) {
MyCallable myCallable = new MyCallable();
FutureTask<String> futureTask = new FutureTask<>(myCallable);
Thread t1 = new Thread(futureTask);
t1.start(); // 启动线程
try {
// 获取Callable任务执行的结果
System.out.println("线程执行结果：" + futureTask.get());
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}
}
}
Callable接口比Runnable接口提供了更强大的功能，特别是当你需要线程返回执行结果时。然而，这也意味着使用Callable会比使用Runnable稍微复杂一些，因为你需要处理Future对象以及可能抛出的异常。