Java多线程 - 线程的创建与启动
一、继承Thread类创建线程类
1.创建步奏：
- 定义
Thread类的子类，重写该类的run()方法，该方法就代表线程需要完成的任务，所以，run方法又被称为线程执行体。 - 创建
Thread的实例，即是创建了线程对象。 - 调用线程对象中的start()方法来启动该线程。
实例代码：
class demo{
public static void main(String[] args) {
AThread first = new AThread();
AThread second = new AThread();
first.start();
second.start();
}
}
class AThread extends Thread{
private int i = 0;
//重写run方法，其中run方法就是线程执行体
@Override
public void run(){
for(; i < 100; i++){
//getName是返回当前线程的名字
System.out.println(getName() + " " + i);
}
}
}二、实现Runnable接口创建线程类
1.创建步奏：
- 定义
Runnable接口的实现类，并且重写该接口的run()方法，与上面所述一样，该run()方法是该线程的线程执行体。 - 创建
Runnable实现类的实例，并且以此实例作为Thread的target来创建Thread对象，其中该Thread对象才是真正的线程对象。
//创建 Runnable 实现类的对象
var st = new SecondThread();
//将 Runnable 实现类的对象作为 Thread 的 target 来创建 Thread 对象，即线程对象
new Thread(st);
//或者在创建 Thread 对象的时候为该 Thread 重新命名
new Thread(st, "新线程0");- 调用线程对象的start() 方法来启动该线程
注意：Runnable对象仅仅作为Thread对象的target，Runnable实现类里包含的run()方法仅仅是作为线程执行体，而实际的线程对象依然是Thread对象的实例，只是该Thread线程负责执行target的run()方法
示例代码：
class demo{
public static void main(String[] args) {
MyThread myThread1 = new MyThread();
MyThread myThread2 = new MyThread();
Thread thread1 = new Thread(myThread1, "第一线程");
Thread thread2 = new Thread(myThread2, "第二线程");
thread1.start();
thread2.start();
}
}
class MyThread implements Runnable{
private int i = 1;
@Override
public void run(){
for (; i < 100; ++i){
System.out.println(Thread.currentThread().getName() + " " + i);
}
}
}三、使用Callable和Future来创建线程
上面一个是通过继承Thread类来实现创建线程，一个是通过实现Runnable接口来创建多线程。其中通过实现Runnable接口创建多线程的时候，Thread类的作用是将run()方法包装成为线程执行体，那么是否可以直接把任意方法都包装成为线程执行体？在C#可以实现任意方法包装成线程执行体，包括有返回值的方法。Java 5开始，Java提供了Callable接口，该接口怎么看都像是Runnable接口的增强版。其中Callable接口提供了一个call()方法可以作为线程执行体，call()方法的功能比run()方法的功能更加强大。
run()方法与call()方法：
-
call()方法可以有返回值 -
call()方法可以声明抛出异常
因此完全可以提供一个Callable对象作为Thread的target，该线程的线程执行体就是该Callable对象的call()方法，但是这里会出现一个问题：即 Callable接口是Java 5新增的接口，且不是Runnable接口的子接口，所以说Callable对象不能够直接作为Thread的target，并且call()方法还有一个返回值，call()方法并非是直接进行调用，而是作为线程执行体进行调用。
获取call()方法的返回值：Java 5中提供了Future接口来代表Callable接口里call()方法的返回值，并且Future接口提供了FutureTask实现类，该实现类实现了Future接口，并实现了Runnable接口，可以作为Thread类的target。
注：Callable接口有泛型限制，Callable接口里的泛型形参类型与call()方法返回值类型相同，而且Callable接口是函数式接口，因此可使用Lambda表达式创建Callable对象。
创建步奏：
- 创建
Callable接口的实现类，并且实现call()方法，该call()方法将作为线程执行体，且该方法有返回值，再创建Callable实现类的实例，从Java 8开始，可以直接使用Lambda表达式创建Callable对象。 - 使用
FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。 - 使用
FutureTask对象作为Thread对象的target创建并且启动线程、 - 调用
FutureTask对象的get()方法来获得子线程执行结束后的返回值。
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
class demo{
public static void main(String[] args) {
FutureTask<Integer> task = new FutureTask<>((Callable<Integer>)() -> {
int i = 0;
for(; i < 100; ++i){
System.out.println(Thread.currentThread().getName() + " " + i);
}
//可以有返回值
return i;
});
new Thread(task, "有返回值的线程").start();
try {
System.out.println("返回值：" + task.get());
}catch(Exception e){
e.printStackTrace();
}
}
}以上采用Lambda表达式直接创建的，无需先创建Callable实现类了。
以下采用创建类的方式
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
class demo{
public static void main(String[] args) throws Exception {
Cal cal = new Cal();
FutureTask<Integer> res = new FutureTask<>(cal);
Thread thread = new Thread(res);
thread.start();
System.out.println(res.get());
}
}
class Cal implements Callable<Integer> {
private int i = 0;
@Override
public Integer call() throws Exception {
for(; i < 100; i++){
System.out.println(Thread.currentThread().getName() + " " + i);
}
return i;
}
}四、创建线程的三种方式对比
通过三个接口，都可以实现多线程，只是Callable接口的定义方法可以有返回值，可以声明跑出异常而已，所以，Runnable接口和实现Callable接口贵为一种方式。
采用Runnable、Callable接口的方式创建多线程的优缺点：
- 线程类只是实现了
Runnable接口或者Callable接口，还可以继承其他类 - 在该方式下，多个线程可以共享同一
target对象，所以非常适合多个相同线程来处理同一份资源的情况，从而将CPU，代码和数据分开，形成清洗模型，体现面向对象思想、 - 编程稍复杂。
采用Thread类的方式创建多线程的优缺点： - 线程类已经继承
Thread类，所以不能在继承其他的父类。 - 优势：编写简单
一般来说，我们使用Runnable和Callable接口的方式创建多线程。
