多线程的三种实现代码

1.使用继承Thread类的方式实现多线程

public class MyThread extends Thread {
    public void run() {
        // 线程要执行的任务逻辑
        System.out.println("Thread is running");
    }

    public static void main(String[] args) {
        // 创建线程对象
        MyThread thread = new MyThread();

        // 启动线程
        thread.start();
    }
}

在上述代码中，我们定义了一个自定义线程类MyThread，该类继承了Thread类，并重写了Thread类的run()方法。在run()方法中编写线程要执行的任务逻辑。在main方法中，我们创建了一个MyThread对象并调用start()方法来启动线程。

当调用start()方法后，新线程将会执行run()方法中的代码逻辑。需要注意的是，在多线程编程中，不要直接调用run()方法，而是通过start()方法来启动线程，因为直接调用run()方法只会在当前线程中以普通方法的方式执行，而不会启动一个新的线程。

使用继承Thread类的方式实现多线程相对简单，但它也有一些局限性，比如无法继承其他类、代码复用性较差等。因此，在实际开发中，更推荐使用实现Runnable接口的方式来实现多线程，具有更好的灵活性和扩展性。

2.使用实现Runnable接口的方式实现多线程：

public class MyRunnable implements Runnable {
    public void run() {
        // 线程要执行的任务逻辑
        System.out.println("Thread is running");
    }

    public static void main(String[] args) {
        // 创建线程对象
        Thread thread = new Thread(new MyRunnable());

        // 启动线程
        thread.start();
    }
}

在上述代码中，我们定义了一个实现了Runnable接口的自定义类MyRunnable。该类实现了Runnable接口，并重写了run()方法，在其中编写线程的任务逻辑。在main方法中，我们创建了一个Thread对象，并将MyRunnable对象作为参数传递给Thread的构造函数。然后，调用start()方法启动线程。

使用Runnable接口的方式实现多线程具有更好的灵活性和扩展性。相比继承Thread类，使用接口的方式可以避免了单继承的限制，同时可以更方便地实现代码的复用。此外，可以通过实现Runnable接口来实现多个线程共享同一个任务实例，从而实现线程之间的数据共享和通信。

需要注意的是，在使用实现Runnable接口的方式时，线程的任务逻辑必须在run()方法中实现，而不是直接在类中编写。在启动线程时，需要将实现了Runnable接口的对象作为参数传递给Thread的构造函数，然后调用start()方法来启动线程。

3.使用Callable接口和Future接口可以实现获取线程执行结果

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

public class MyCallable implements Callable<String> {
    public String call() throws Exception {
        // 线程要执行的任务逻辑
        return "Thread is running";
    }

    public static void main(String[] args) {
        // 创建Callable对象
        Callable<String> callable = new MyCallable();

        // 创建FutureTask对象
        FutureTask<String> futureTask = new FutureTask<>(callable);

        // 创建线程对象
        Thread thread = new Thread(futureTask);

        // 启动线程
        thread.start();

        try {
            // 获取线程执行结果
            String result = futureTask.get();
            System.out.println(result);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

在上述代码中，我们定义了一个实现了Callable接口的自定义类MyCallable。该类实现了Callable接口，并重写了call()方法，在其中编写线程的任务逻辑，并返回一个结果。

在main方法中，我们创建了一个Callable对象，并将其作为参数传递给FutureTask的构造函数来创建一个FutureTask对象。然后，我们创建一个线程对象，并将FutureTask对象作为参数传递给Thread的构造函数。最后，我们调用start()方法启动线程。

通过调用FutureTask的get()方法，我们可以获取线程的执行结果。如果线程的任务逻辑已经执行完毕，那么get()方法会立即返回结果。如果线程的任务逻辑还未完成，那么get()方法会阻塞等待，直到任务完成并返回结果。

需要注意的是，调用FutureTask的get()方法可能会抛出InterruptedException和ExecutionException异常，因此在调用get()方法时需要进行异常处理。

使用Callable接口和Future接口可以实现更灵活的线程任务，并能获取线程的执行结果，非常适用于需要线程返回结果的场景。