一、线程的三种创建方式：
1、继承 Tread类， 重写 run方法；
2、实现 Runnable接口，实现 run方法；
3、实现 Callable接口，实现 call方法，该方式可以获取线程的执行结果。
二、继承 Tread类
1、创建步骤：
- 创建一个继承于 Thread类的子类
- 重写Thread类的 run()方法->此线程执行的操作声明在 run()中，如遍历100以内所有的偶数
- 创建此子类对象
- 调用 start()方法：有两个作用：①启动当前线程 ②调用当前线程的 run()
2.代码实现
/**
* @Author js
* @Date 2023/10/1 11:21
* @Description :
*/
/**
* @Classname: ExtendsThread
* @Description: 继承 Tread类, 重写 run方法
*/
public class ExtendsThread extends Thread {
/** 线程名称 */
private final String THREAD_NAME;
public ExtendsThread(String THREAD_NAME) {
this.THREAD_NAME = THREAD_NAME;
}
/**
* 重写 run方法
*/
public void run() {
// 业务逻辑
for (int i = 0; i < 1000; i++) {
System.out.println(THREAD_NAME + "--" + i);
}
}
public static void main(String[] args) {
ExtendsThread thread1 = new ExtendsThread("线程A");
ExtendsThread thread2 = new ExtendsThread("线程B");
// 启动线程
thread1.start();
thread2.start();
}
}
3.注意:
- 在调用线程对象的
start()方法之前，线程处于NEW（新建）状态；调用后，线程进入就绪状态等待CPU时间片，一旦获得时间片就开始执行run()方法中的业务逻辑。 - 由于线程的执行是并发的，因此输出结果可能会有交错。
三、实现 Runnable接口
1、创建步骤：
- 创建一个实现了 Runnable接口的类
- 实现类去实现 Runnable接口中的抽象方法：run()
- 创建实现类的对象
- 将此实现类作为参数传递到 Thread类的构造器中，创建 Thread类的对象
- 通过 Thread类的对象调用 start()
2.代码实现
/**
* @Author js
* @Date 2023/10/1 11:31
* @Description :
*/
/**
* @Classname: ImplementsRunnable
* @Description: 实现 Runnable接口, 实现 run方法
*/
public class ImplementsRunnable implements Runnable {
/** 线程名称 */
private final String THREAD_NAME;
public ImplementsRunnable(String THREAD_NAME) {
this.THREAD_NAME = THREAD_NAME;
}
/**
* 实现 run方法
*/
@Override
public void run() {
// 业务逻辑
for (int i = 0; i < 1000; i++) {
System.out.println(THREAD_NAME + "--" + i);
}
}
public static void main(String[] args) {
ImplementsRunnable runnable1 = new ImplementsRunnable("线程A");
ImplementsRunnable runnable2 = new ImplementsRunnable("线程B");
// 实例化 Thread类对象
Thread thread1 = new Thread(runnable1);
Thread thread2 = new Thread(runnable2);
// 启动线程
thread1.start();
thread2.start();
}
}
3.注意：
- 与继承Thread类相比，实现Runnable接口可以避免单继承的限制，而且共享同一个Runnable实例给多个线程使用可以减少开销和提高效率。
- 调用Thread类的构造方法时需要传入一个实现了Runnable接口的对象作为参数。
- 实现了Runnable接口的类必须实现其中的
run()方法，此方法中包含了线程执行的业务逻辑。
四、实现 Callable接口
1、创建步骤：
- 创建一个实现 Callable接口的实现类
- 实现 call()方法，将此线程需要执行的操作声明在 call()中
- 创建 Callable接口实现类的对象
- 将此 Callable接口实现类的对象作为参数传递到 FutureTask构造器中，创建 FutureTask对象
- 将 FutureTask的对象作为参数传递到 Thread类的构造器中，创建 Thread对象，并调用 start()
- 如果对返回值感兴趣，则通过 FutureTask对象的 get()方法获取 Callable中 call()的返回值
2.代码实现
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
/**
* @Author js
* @Date 2023/10/1 11:42
* @Description :
*/
/**
* @Classname: ImplementsCallable
* @Description: 实现 Callable接口, 实现 call方法, 该方式可以获取线程的执行结果
*/
public class ImplementsCallable implements Callable<Integer> {
/** 线程名称 */
private final String THREAD_NAME;
public ImplementsCallable(String THREAD_NAME) {
this.THREAD_NAME = THREAD_NAME;
}
@Override
public Integer call() throws Exception {
// 业务逻辑
int j = 0;
for (int i = 0; i < 1000; i++) {
System.out.println(THREAD_NAME + "--" + i);
j = i;
}
return j;
}
public static void main(String[] args) {
FutureTask<Integer> futureTask = new FutureTask<>(new ImplementsCallable("线程A"));
// 实例化 Thread类对象
Thread thread = new Thread(futureTask);
// 启动线程
thread.start();
for (int i = 0; i < 1000; i++) {
System.out.println("线程B" + "--" + i);
}
// 获取线程执行结果。如果此时获取结果的任务还未执行完成，会让出CPU，直至任务执行完成才获取结果
try {
Integer integer = futureTask.get();
System.out.println(integer);
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}
}
}
3.注意：
- 与实现Runnable接口不同，实现Callable接口可以通过FutureTask类来获取线程执行结果。
- 调用FutureTask类的构造方法时需要传入一个实现了Callable接口的对象作为参数。
- 实现了Callable接口的类必须实现其中的
call()方法，此方法中包含了线程执行的业务逻辑，并且有返回值。