什么是多线程 ，java创建多线程方式
多线程
1.什么是多线程，为什么使用多线程？
线程首先得说到进程，
进程：正在执行的应用程序。是系统进行资源分配和调用的独立单元。每一个进程都有他自己的内存空间和系统资源，简单说就是程序进入内存运行变成一个进程，具有一定独立功能。
线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。
什么是多线程呢？
即就是一个程序中有多个线程在同时执行。
如果只用单线程响应HTTP请求，即处理完一条请求，再处理下一条请求的话，CPU会存在大量的闲置时间 。
相比单线程顺序执行，多线程提高了应用程序的使用率。
创建多线程
创建多线程有三种方式：
1.继承 Thread 类创建线程
使用继承 Thread 类创建线程的步骤如下：
1.新建一个类继承 Thread 类，并重写 Thread 类的 run() 方法。
2.创建 Thread 子类的实例。
3.调用该子类实例的 start() 方法启动该线程。
代码举例如下：
public class ThreadDemo extends Thread {
// 1. 新建一个类继承 Thread 类，并重写 Thread 类的 run() 方法。
@Override
public void run() {
System.out.println("Hello Thread");
}
public static void main(String[] args) {
// 2. 创建 Thread 子类的实例。
ThreadDemo threadDemo = new ThreadDemo();
// 3. 调用该子类实例的 start() 方法启动该线程。
threadDemo.start();
}
}
2.实现 Runnable 接口创建线程
使用实现 Runnable 接口创建线程步骤是：
1.创建一个类实现 Runnable 接口，并重写该接口的 run() 方法。
2.创建该实现类的实例。
3.将该实例传入 Thread(Runnable r) 构造方法中创建 Thread 实例。
4.调用该 Thread 线程对象的 start() 方法。
代码举例如下：
public class RunnableDemo implements Runnable {
// 1. 创建一个类实现 Runnable 接口，并重写该接口的 run() 方法。
@Override
public void run() {
System.out.println("Hello Runnable");
}
public static void main(String[] args) {
// 2. 创建该实现类的实例。
RunnableDemo runnableDemo = new RunnableDemo();
// 3. 将该实例传入 Thread(Runnable r) 构造方法中创建 Thread 实例。
Thread thread = new Thread(runnableDemo);
// 4. 调用该 Thread 线程对象的 start() 方法。
thread.start();
}
}
3.使用 Callable 和 FutureTask 创建线程
使用这种方法创建的线程可以获取一个返回值，使用实现 Callable 和 FutureTask 创建线程步骤是：
1.创建一个类实现 Callable 接口，并重写 call() 方法。
2.创建该 Callable 接口实现类的实例。
3.将 Callable 的实现类实例传入 FutureTask(Callable callable) 构造方法中创建 FutureTask 实例。
4.将 FutureTask 实例传入 Thread(Runnable r) 构造方法中创建 Thread 实例。
5.调用该 Thread 线程对象的 start() 方法。
6.调用 FutureTask 实例对象的 get() 方法获取返回值。
代码举例如下：
public class CallableDemo implements Callable<String> {
// 1. 创建一个类实现 Callable 接口，并重写 call() 方法。
@Override
public String call() throws Exception {
System.out.println("CallableDemo is Running");
return "Hello Callable";
}
public static void main(String[] args) {
// 2. 创建该 Callable 接口实现类的实例。
CallableDemo callableDemo = new CallableDemo();
// 3. 将 Callable 的实现类实例传入 FutureTask(Callable<V> callable) 构造方法中创建 FutureTask 实例。
FutureTask<String> futureTask = new FutureTask<>(callableDemo);
// 4. 将 FutureTask 实例传入 Thread(Runnable r) 构造方法中创建 Thread 实例。
Thread thread = new Thread(futureTask);
// 5. 调用该 Thread 线程对象的 start() 方法。
thread.start();
// 6. 调用 FutureTask 实例对象的 get() 方法获取返回值。
try {
System.out.println(futureTask.get());
} catch (Exception e) {
e.printStackTrace();
}
}
}
线程生命周期：
当一个线程开启之后，它会遵循一定的生命周期，它要经过新建，就绪，运行，阻塞和死亡这五种状态，理解线程的生命周期有助于理解后面的相关的线程知识。
1 新建状态
这个状态的意思就是线程刚刚被创建出来，这时候的线程并没有任何线程的动态特征。
2 就绪状态
当线程对象调用 start() 方法后，该线程就处于就绪状态。处于这个状态中的线程并没有开始运行，只是表示这个线程可以运行了。
3 运行状态
处于就绪状态的线程获得了 CPU 后，开始执行 run() 方法，这个线程就处于运行状态。
4 阻塞状态
当线程被暂停后，这个线程就处于阻塞状态。
5 死亡状态
当线程被停止后，这个线程就处于死亡状态。