在Java中，可以使用以下几种方式来创建线程：

1、继承Thread类：可以创建一个类，继承java.lang.Thread类，并重写run()方法来定义线程代码。然后，可以创建一个新的Thread对象，并调用start()方法来启动线程

class MyThread extends Thread {
    public void run() {
        // 线程代码
    }
}

// 创建新线程并启动
MyThread thread = new MyThread();
thread.start();

2、实现Runnable接口：可以创建一个类，实现java.lang.Runnable接口，并实现run()方法来定义线程代码。然后，可以创建一个新的Thread对象，并将Runnable实例传递给Thread构造函数。

class MyRunnable implements Runnable {
    public void run() {
        // 线程代码
    }
}

// 创建新线程并启动
MyRunnable runnable = new MyRunnable();
Thread thread = new Thread(runnable);
thread.start();

3、实现Callable接口：可以创建一个类，实现java.util.concurrent.Callable接口，并实现call方法来定义线程代码。然后，可以创建一个新的Thread对象，并将Runnable实例传递给Thread构造函数。

import java.util.concurrent.*;

class MyCallable implements Callable<Integer> {
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 10; i++) {
            sum += i;
        }
        return sum;
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建线程池
        ExecutorService executor = Executors.newSingleThreadExecutor();

        // 提交可调用任务
        Future<Integer> future = executor.submit(new MyCallable());

        try {
            // 等待计算完成并获取结果
            int result = future.get();
            System.out.println("结果：" + result);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

        // 关闭线程池
        executor.shutdown();
    }
}

4、使用匿名内部类：可以使用匿名内部类来创建线程，避免创建多个类。可以在Thread构造函数中传递一个Runnable对象的匿名内部类来定义线程代码。

// 创建新线程并启动
Thread thread = new Thread(new Runnable() {
    public void run() {
        // 线程代码
    }
});
thread.start();

5、使用Lambda表达式：可以使用Lambda表达式来创建线程，避免创建多个类。可以在Thread构造函数中传递一个Runnable对象的Lambda表达式来定义线程代码。

// 创建新线程并启动
Thread thread = new Thread(() -> {
    // 线程代码
});
thread.start();