多线程编程之一——线程启动的三种方式

启动线程的三种方式

一般启动线程有三种方式，分别是继承 java.lang.Thread 类，实现Runnable接口，实现Callable接口，下面给出这三种方式的实现代码。

方式一：继承 java.lang.Thread 类

package com.pangcq.concurrent.start;

/**
 * 线程启动的第一种方式
 */
// 1. 继承Thread类
public class SubThread extends Thread {

    // 2.重写run方法，线程要执行的任务在run方法中
    @Override
    public void run() {
        while (true) {
            System.out.println("继承Thread类的子线程");
        }
    }
}

方式二：实现Runnable接口

package com.pangcq.concurrent.start;

/**
 * 线程启动的第二种方式
 */
// 1.实现Runnable接口
public class RunnableThread implements Runnable {

    // 2.重写run方法
    @Override
    public void run() {
        while (true) {
            System.out.println("实现Runnable接口的子线程");
        }
    }
}

方式三：实现Callable接口

package com.pangcq.concurrent.start;

import java.util.concurrent.Callable;

/**
 * 线程启动的第三种方式
 */
// 1.实现Callable接口
public class CallableThread implements Callable<String> {

    // 2.重写call方法
    @Override
    public String call() throws Exception {
        System.out.println("实现Callable的线程");
        return "Callable";
    }
}

测试代码

package com.pangcq.concurrent.start;

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

/**
 * 线程测试类
 */
public class ThreadTest {
    public static void main(String[] args) {

        /**
         * 第一种启动线程的方式
         * 步骤：
         * 1. 继承Thread类
         * 2. 重写run()方法
         * 3. 创建Thread子类实列
         * 4. 调用start()方法启动线程
         */
        SubThread thread1 = new SubThread();
        thread1.start();

        /**
         * 第二种启动线程的方式
         * 步骤：
         * 1. 实现Runnable接口
         * 2. 重写run()方法
         * 3. 将Runnable子类实列交给Thread构造器，创建Thread子类实列
         * 4. 调用start()方法启动线程
         */
        RunnableThread runnableThread = new RunnableThread();
        Thread thread2 = new Thread(runnableThread);
        thread2.start();

        /**
         * 第三种启动线程的方式
         * 步骤：
         * 1. 实现Callable接口
         * 2. 重写call()方法
         * 3. 将Callable接口的实例交给FutureTask的构造器
         * 4. 将FutureTask的实例交给Thread的构造器
         * 5. 调用start()方法启动线程
         */
        // 3. 将Callable接口的实例交给FutureTask的构造器
        FutureTask<String> futureTask = new FutureTask<>(new CallableThread());
        // 4. 将FutureTask的实例交给Thread的构造器
        Thread thread3 = new Thread(futureTask);
        // 5. 调用start()方法启动线程
        thread3.start();
        try {
            String result = futureTask.get();   // get()方法在获取到结果之前，一直阻塞
            System.out.println(result);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

参考——
博学谷