多线程是指在软件或硬件上实现多个线程并发执行的技术。为了更好地理解多线程，首先需要了解几个基本概念：
了解概念
1.程序
程序是为完成特定任务、用某种语言编写的一组指令的集合。它是一个静态的概念，通常存储在磁盘或其他非易失性存储器中，说白了就是我们写的代码。
2.进程
进程是程序的一次执行过程，是系统进行资源分配和调度的基本单位。每个进程都有独立的内存空间和系统资源。
3.线程
线程是进程中的一个执行单元，是CPU调度和分派的基本单位。一个进程可以包含多个线程，这些线程共享进程的资源，但每个线程有自己的栈和寄存器状态。
4.并发
并发是指多个任务在同一时间段内交替执行，但由于CPU切换任务的速度非常快，给人的感觉像是同时执行。
5.并行
并行是指多个任务在同一时刻真正的同时执行，这通常需要多核处理器或其他并行处理硬件的支持。
6.cpu核
CPU核是处理器的计算单元，一个多核处理器可以在同一时刻执行多个线程，从而实现并行处理。
基本使用方法
多线程编程是提高程序并发处理能力的重要手段。下面通过具体的代码示例来展示如何使用多线程
1. 通过继承Thread类
// 通过继承Thread类来创建线程
class MyThread extends Thread {
// 重写run方法，线程启动后将执行run方法中的代码
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName() + " 执行 " + i);
try {
// 线程休眠100毫秒
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public class ThreadDemo {
public static void main(String[] args) {
// 创建两个线程对象
MyThread thread1 = new MyThread();
MyThread thread2 = new MyThread();
// 启动线程
thread1.start();
thread2.start();
}
}
MyThread类继承了Thread类，并重写了run方法。- 在
main方法中创建了两个MyThread对象，并调用start方法启动线程。
2. 实现Runnable接口
// 通过实现Runnable接口来创建线程
class MyRunnable implements Runnable {
// 实现run方法，线程启动后将执行run方法中的代码
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName() + " 执行 " + i);
try {
// 线程休眠100毫秒
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public class RunnableDemo {
public static void main(String[] args) {
// 创建Runnable对象
MyRunnable myRunnable = new MyRunnable();
// 创建两个线程对象，并将Runnable对象作为参数传递给Thread构造函数
Thread thread1 = new Thread(myRunnable);
Thread thread2 = new Thread(myRunnable);
// 启动线程
thread1.start();
thread2.start();
}
}
MyRunnable类实现了Runnable接口，并实现了run方法。- 在
main方法中创建了一个MyRunnable对象，并将其作为参数传递给两个Thread对象，然后调用start方法启动线程。
3. 通过Callable和Future创建线程
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
// 通过实现Callable接口来创建线程
class MyCallable implements Callable<Integer> {
// 实现call方法，线程启动后将执行call方法中的代码，并返回一个结果
@Override
public Integer call() throws Exception {
int sum = 0;
for (int i = 0; i < 5; i++) {
sum += i;
System.out.println(Thread.currentThread().getName() + " 执行 " + i);
try {
// 线程休眠100毫秒
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
return sum;
}
}
public class CallableDemo {
public static void main(String[] args) {
// 创建Callable对象
MyCallable myCallable = new MyCallable();
// 创建FutureTask对象，并将Callable对象作为参数传递给FutureTask构造函数
FutureTask<Integer> futureTask1 = new FutureTask<>(myCallable);
FutureTask<Integer> futureTask2 = new FutureTask<>(myCallable);
// 创建线程对象，并将FutureTask对象作为参数传递给Thread构造函数
Thread thread1 = new Thread(futureTask1);
Thread thread2 = new Thread(futureTask2);
// 启动线程
thread1.start();
thread2.start();
try {
// 获取线程执行结果
System.out.println("Thread 1 结果: " + futureTask1.get());
System.out.println("Thread 2 结果: " + futureTask2.get());
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}
}
}
MyCallable类实现了Callable接口，并实现了call方法，该方法返回一个整数结果。- 在
main方法中创建了一个MyCallable对象，并将其作为参数传递给两个FutureTask对象。- 将
FutureTask对象作为参数传递给两个Thread对象，并调用start方法启动线程。- 使用
FutureTask的get方法获取线程的执行结果。
总结
可以看到，Thread实现了Runnable接口 ，他是一个类，我们可以直接继承Thread类来实现线程，也可以通过直接实现Runnable接口来使用，感兴趣的可以自己去看一下源码，然而Threa本身并没有Run方法，Run方法是接口里面的。
多线程的底层实现机制原理涉及到线程调度、同步和互斥等概念。操作系统通过线程调度器来决定哪个线程在何时执行。为了确保多个线程能够正确地共享资源，需要使用同步机制，如锁（synchronized关键字）和条件变量（如Java中的wait和notify方法）。 多线程想要理解透彻需要花费一定的时间，也有难度，底层原理我会后面再写，今天这篇文章只需要简单了解入门即可。
