线程的创建方式

junxianboy

已于 2022-09-20 08:55:59 修改

阅读量9k

点赞数 8

文章标签： java 开发语言

于 2022-09-19 10:31:22 首次发布

本文链接：https://blog.csdn.net/weixin_46760166/article/details/126928510

版权

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

1、继承 Tread类，重写 run方法

2、实现 Runnable接口，实现 run方法

3、实现 Callable接口，实现 call方法，该方式可以获取线程的执行结果

二、继承 Tread类

1、创建步骤：

> 创建一个继承于 Thread类的子类

> 重写Thread类的 run()方法->此线程执行的操作声明在 run()中，如遍历100以内所有的偶数

> 创建此子类对象

> 调用 start()方法：有两个作用：①启动当前线程 ②调用当前线程的 run()

2、代码

package com.tjx.thread.create;

/**
 * @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();
    }

}

三、实现 Runnable接口

1、创建步骤：

> 创建一个实现了 Runnable接口的类

> 实现类去实现 Runnable接口中的抽象方法：run()

> 创建实现类的对象

> 将此实现类作为参数传递到 Thread类的构造器中，创建 Thread类的对象

> 通过 Thread类的对象调用 start()

2、代码

package com.tjx.thread.create;

/**
 * @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();
    }

}

四、实现 Callable接口

1、创建步骤：

> 创建一个实现 Callable接口的实现类

> 实现 call()方法，将此线程需要执行的操作声明在 call()中

> 创建 Callable接口实现类的对象

> 将此 Callable接口实现类的对象作为参数传递到 FutureTask构造器中，创建 FutureTask对象

> 将 FutureTask的对象作为参数传递到 Thread类的构造器中，创建 Thread对象，并调用 start()

> 如果对返回值感兴趣，则通过 FutureTask对象的 get()方法获取 Callable中 call()的返回值

2、代码

package com.tjx.thread.create;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 * @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();
        }
    }

}