线程的三种创建方式-526互联

一、线程的三种创建方式：

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()方法，此方法中包含了线程执行的业务逻辑，并且有返回值。