并发编程（二）线程创建的三种方式

Java中有三种线程创建方式

• 实现Runnable接口的run方法
• 继承Thread类并重写run的方法
• 使用FutureTask方式

继承Thread类并重写run的方法

public class ThreadTest {
    //继承Thread类并重写run方法
    public static class MyThread extends Thread {
        @Override
        public void run() {
            System.out.println("I am a child thread");
        }
    public static void main(String[] args) {
        // 创建线程
        MyThread thread = new MyThread();
        // 启动线程
        thread.start();
    }
}

创建MyThread类继承了Thread类，并重写了run（）方法。在main函数里面创建了一个MyThread的实例，然后调用该实例的start方法启动了线程。需要注意的是，当创建完thread对象后该线程并没有被启动执行，直到调用了start方法后才真正启动了线程。其实调用start方法后线程并没有马上执行而是处于就绪状态，这个就绪状态是指该线程已经获取了除CPU资源外的其他资源，等待获取CPU资源后才会真正处于运行状态。一旦run方法执行完毕，该线程就处于终止状态。

使用继承方式的好处是，在run（）方法内获取当前线程直接使用this就可以了，无须使用Thread.currentThread（）方法；不好的地方是Java不支持多继承，如果继承了Thread类，那么就不能再继承其他类。另外任务与代码没有分离，当多个线程执行一样的任务时需要多份任务代码。

实现Runnable接口的run方法

public class RunnableTask implements Runnable {
    public void run() {
        // 定义任务的具体逻辑
        System.out.println("Runnable task is running.");
    }
}

public class Main {
    public static void main(String[] args) {
        RunnableTask task = new RunnableTask();
        
        // 创建线程，并将任务对象作为参数传递给线程
        Thread thread1 = new Thread(task);
        Thread thread2 = new Thread(task);
        
        // 启动线程
        thread1.start();
        thread2.start();
    }
}

• Thread类源码中的构造器，将业务逻辑写在Runable的实现类中，然后传给Thread执行

public Thread(Runnable target) {
    this(null, target, "Thread-" + nextThreadNum(), 0);
}

public Thread(ThreadGroup group, String name) {
    this(group, null, name, 0);
}

两个线程共用一个task代码逻辑，如果需要，可以给RunableTask添加参数（第二种构造器）进行任务区分。
这样做到了业务逻辑和线程创建的分离，但是没有返回值，无法获得线程的执行情况。

使用FutureTask方式

public class CallerTask implements Callable<String> {
    public String call() throws Exception {
        // 定义任务的具体逻辑
        return "Callable task is running.";
    }
}

public class Main {
    public static void main(String[] args) throws Exception {
        CallerTask callerTask = new CallerTask();
        
        // 创建 FutureTask 对象，并将 Callable 任务对象作为参数传递给 FutureTask
        FutureTask<String> futureTask = new FutureTask<>(callerTask);
        
        // 创建线程，并将 FutureTask 对象作为参数传递给线程
        Thread thread = new Thread(futureTask);
        
        // 启动线程
        thread.start();
        
        // 获取任务的返回结果
        String result = futureTask.get();
        System.out.println(result);
    }
}

FutureTask部分源码

/** The underlying callable; nulled out after running */
private Callable<V> callable;

略

public FutureTask(Callable<V> callable) {
    if (callable == null)
        throw new NullPointerException();
    this.callable = callable;
    this.state = NEW;       // ensure visibility of callable
}

• FutureTask<String> 实现了 RunnableFuture接口，而RunnableFuture继承了 Future 接口和Runnable 接口，并且还可以包装一个 Callable 或 Runnable 对象。
• 通过将 Callable 或 Runnable对象传递给 FutureTask 的构造方法，可以创建一个带有返回结果的任务。
• 创建异步任务并将其作为参数传递给 FutureTask，再将 FutureTask 传递给新的线程，是一种常见的多线程编程模式。
• 当运行一个Java程序时，会创建一个主线程，并从 main 方法开始执行。这个主线程是程序的起始线程，负责执行 main 方法中定义的代码。
• 而使用 new Thread() 创建一个新的线程，程序可以通过调用该线程的 start() 方法来启动并执行线程中的代码。通过创建新线程，可以并发地执行多个任务，而不会阻塞主线程的执行。