Java多线程的常用创建方式总结

我们来讲解一下“Java多线程的常用创建方式总结”的完整攻略。

1. 概述

Java多线程是Java程序中一个非常重要的概念，它可以提高程序的运行效率，实现并发执行。在Java中，创建线程的方式有很多种，本文将总结和介绍几种常用的线程创建方式。

2. 继承Thread类

继承Thread类是Java多线程中最常用的一种创建方式。它主要通过继承Thread类来创建新的线程，并重写Thread类的run()方法来实现线程执行的逻辑。

public class MyThread extends Thread {
    public void run() {
        // 线程执行的代码逻辑
    }

    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
    }
}

上面的代码中，我们继承了Thread类并重写了run()方法，将我们需要执行的代码放在了run()方法中。同时，我们调用了start()方法启动了线程。

3. 实现Runnable接口

实现Runnable接口是Java多线程中另一种常用的创建方式。它主要是通过实现Runnable接口，并将实现了Runnable接口的类传给Thread类的构造方法中来创建新的线程。

public class MyRunnable implements Runnable {
    public void run() {
        // 线程执行的代码逻辑
    }

    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start();
    }
}

上面的代码中，我们实现了Runnable接口，并重写了run()方法来实现线程需要执行的代码逻辑。同时，我们通过创建一个Thread对象，并将实现了Runnable接口的myRunnable对象传递给它来创建了一个新的线程。

4. 使用Callable和Future接口

Callable和Future接口是从Java 5开始引入的，它们提供了一种创建线程的新方式，并且可以返回线程执行结果。

public class MyCallable implements Callable<Integer> {
    public Integer call() throws Exception {
        // 线程执行的代码逻辑
        return 0;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyCallable myCallable = new MyCallable();
        FutureTask<Integer> futureTask = new FutureTask<>(myCallable);
        Thread thread = new Thread(futureTask);
        thread.start();
        Integer result = futureTask.get();
    }
}

上面的代码中，我们实现了Callable接口，并重写了它的call()方法来实现线程需要执行的代码逻辑，并返回了一个Integer型的值。我们使用FutureTask类来将Callable接口的实现类包装成一个任务，通过创建一个Thread来执行这个任务，并通过调用FutureTask的get()方法来获取线程执行的结果。

5. 示例说明

我们来举两个例子，对上面讲解的线程创建方式进行说明：

5.1 继承Thread类创建新线程

public class ThreadDemo extends Thread {
    public static void main(String[] args) {
        ThreadDemo threadDemo = new ThreadDemo();
        threadDemo.start();
        System.out.println("主线程执行完毕");
    }

    public void run() {
        System.out.println("子线程开始执行");
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程执行：" + i);
        }
        System.out.println("子线程执行完毕");
    }
}

上面的代码中，我们继承Thread类，重写了run()方法，并将需要执行的代码放在了run()方法中。在main()方法中，我们创建了一个ThreadDemo对象，调用start()方法启动了线程，并在终端打印了“主线程执行完毕”的信息。子线程中的代码执行完后，“子线程执行完毕”的信息会被输出。

5.2 实现Runnable接口创建新线程

public class RunnableDemo implements Runnable {

    public static void main(String[] args) {
        RunnableDemo runnableDemo = new RunnableDemo();
        Thread thread = new Thread(runnableDemo);
        thread.start();
        System.out.println("主线程执行完毕");
    }

    @Override
    public void run() {
        System.out.println("子线程开始执行");
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程执行：" + i);
        }
        System.out.println("子线程执行完毕");
    }
}

上面的代码中，我们实现了Runnable接口，重写了run()方法，并将需要执行的代码放在了run()方法中。在main()方法中，我们创建了一个RunnableDemo对象，将这个对象传递给Thread类的构造方法，创建了一个新的线程，并启动了这个线程。我们在终端打印了“主线程执行完毕”的信息。子线程中的代码执行完后，“子线程执行完毕”的信息会被输出。

6. 总结

Java多线程的常用创建方式有继承Thread类、实现Runnable接口和使用Callable和Future接口，本文主要介绍了这三种创建方式的使用方法，并且通过两个简单的示例对这些内容进行了说明。