线程创建的几种方式，你都知道吗？

使用继承 Thread 类的方法来创建线程，分别表示兔子和乌龟的比赛。

class Turtle extends Thread {
    @Override
    public void run() {
        System.out.println("乌龟开始赛跑！");
        for (int i = 1; i <= 10; i++) {
            System.out.println("乌龟跑了 " + i + " 米。");
            try {
                Thread.sleep(1000); // 乌龟慢慢跑
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("乌龟到达终点，乌龟获胜！");
    }
}

class Rabbit extends Thread {
    @Override
    public void run() {
        System.out.println("兔子开始赛跑！");
        for (int i = 1; i <= 10; i++) {
            System.out.println("兔子跑了 " + i + " 米。");
            if (i % 3 == 0) {
                System.out.println("兔子停下来休息一下。");
                try {
                    Thread.sleep(2000); // 兔子休息
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        System.out.println("兔子到达终点，兔子获胜！");
    }
}

public class RaceExample {
    public static void main(String[] args) {
        Turtle turtle = new Turtle();
        Rabbit rabbit = new Rabbit();
        
        turtle.start(); // 启动乌龟线程
        rabbit.start(); // 启动兔子线程
    }
}

结果

2. 实现 Runnable 接口
实现 Runnable 接口的方式，分别表示兔子和乌龟的比赛

class TurtleRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("乌龟开始赛跑！");
        for (int i = 1; i <= 10; i++) {
            System.out.println("乌龟跑了 " + i + " 米。");
            try {
                Thread.sleep(1000); // 乌龟慢慢跑
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("乌龟到达终点，乌龟获胜！");
    }
}

class RabbitRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("兔子开始赛跑！");
        for (int i = 1; i <= 10; i++) {
            System.out.println("兔子跑了 " + i + " 米。");
            if (i % 3 == 0) {
                System.out.println("兔子停下来休息一下。");
                try {
                    Thread.sleep(2000); // 兔子休息
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        System.out.println("兔子到达终点，兔子获胜！");
    }
}

public class RaceRunnableExample {
    public static void main(String[] args) {
        Thread turtleThread = new Thread(new TurtleRunnable());
        Thread rabbitThread = new Thread(new RabbitRunnable());
        
        turtleThread.start(); // 启动乌龟线程
        rabbitThread.start(); // 启动兔子线程
    }
}

运行结果

3. 使用 Callable 和 Future
使用 Callable 和 Future 来实现龟兔赛跑的例子

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

class TurtleCallable implements Callable<String> {
    @Override
    public String call() {
        StringBuilder result = new StringBuilder("乌龟开始赛跑！\n");
        for (int i = 1; i <= 10; i++) {
            result.append("乌龟跑了 ").append(i).append(" 米。\n");
            try {
                Thread.sleep(1000); // 乌龟慢慢跑
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        result.append("乌龟到达终点，乌龟获胜！");
        return result.toString();
    }
}

class RabbitCallable implements Callable<String> {
    @Override
    public String call() {
        StringBuilder result = new StringBuilder("兔子开始赛跑！\n");
        for (int i = 1; i <= 10; i++) {
            result.append("兔子跑了 ").append(i).append(" 米。\n");
            if (i % 3 == 0) {
                result.append("兔子停下来休息一下。\n");
                try {
                    Thread.sleep(2000); // 兔子休息
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        result.append("兔子到达终点，兔子获胜！");
        return result.toString();
    }
}

public class RaceCallableExample {
    public static void main(String[] args) {
        FutureTask<String> turtleTask = new FutureTask<>(new TurtleCallable());
        FutureTask<String> rabbitTask = new FutureTask<>(new RabbitCallable());
        
        Thread turtleThread = new Thread(turtleTask);
        Thread rabbitThread = new Thread(rabbitTask);
        
        turtleThread.start(); // 启动乌龟线程
        rabbitThread.start(); // 启动兔子线程
        
        try {
            System.out.println(turtleTask.get()); // 打印乌龟的结果
            System.out.println(rabbitTask.get()); // 打印兔子的结果
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

4. 使用线程池（Executor 框架）
   使用 Executor 框架来管理线程的龟兔赛跑例子。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class RaceExecutorExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(2); // 创建一个固定大小的线程池

        executor.submit(() -> {
            System.out.println("乌龟开始赛跑！");
            for (int i = 1; i <= 10; i++) {
                System.out.println("乌龟跑了 " + i + " 米。");
                try {
                    Thread.sleep(1000); // 乌龟慢慢跑
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("乌龟到达终点，乌龟获胜！");
        });

        executor.submit(() -> {
            System.out.println("兔子开始赛跑！");
            for (int i = 1; i <= 10; i++) {
                System.out.println("兔子跑了 " + i + " 米。");
                if (i % 3 == 0) {
                    System.out.println("兔子停下来休息一下。");
                    try {
                        Thread.sleep(2000); // 兔子休息
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
            System.out.println("兔子到达终点，兔子获胜！");
        });

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

1.继承 Thread 类: 简单易用，适合不需要共享状态的简单任务。每个线程都代表一个独立的类。

2.实现 Runnable 接口: 可以实现更灵活的线程管理，可以共享同一个任务实例。适合需要多个线程共享资源的情况。

3.使用 Callable 和 Future: 允许线程返回结果和处理异常，适合需要获取计算结果的场景。

4.使用线程池: 适合需要管理大量线程的场景，通过复用线程降低开销。