1. 继承Thread类
这种方式是通过创建一个新的类继承自Thread类，并覆盖run()方法来创建线程。然后通过创建这个类的对象并调用其start()方法来启动线程。
public class MyThread extends Thread {
    public void run() {
        // 在这里定义线程的执行逻辑
    }

 

    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start(); // 启动线程
    }
}

2. 实现Runnable接口
这种方式是通过创建一个实现了Runnable接口的类，并实现run()方法来创建线程。然后将这个类的对象作为参数传递给Thread类的构造器，并调用Thread对象的start()方法来启动线程。
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(); // 启动线程
    }
}

这种方式的优点在于，由于Java不支持多重继承，如果你的类需要继承其他类，那么实现Runnable接口将是唯一的选择。同时，这也使得你的线程类更加灵活，可以被设计成实现多个接口。
3. 实现Callable接口
这种方式是通过创建一个实现了Callable接口的类，实现call()方法，并使用FutureTask或者ExecutorService来创建线程。这种方式可以让你的线程带返回值。
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class CallableExample implements Callable<String> {

    @Override
    public String call() throws Exception {
        System.out.println("Callable task is running on another thread");
        return "Callable result";
    }

    public static void main(String[] args) {
        CallableExample callableExample = new CallableExample();
        FutureTask<String> futureTask = new FutureTask<>(callableExample);

        Thread thread = new Thread(futureTask);
        thread.start();

        try {
            System.out.println(futureTask.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

这种方式允许你在call()方法中返回一个值，并且可以通过FutureTask的get()方法获取这个值。