
## 1. 继承Thread类
```java
class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("线程执行: " + Thread.currentThread().getName());
    }
}

// 使用
MyThread thread = new MyThread();
thread.start();
```

## 2. 实现Runnable接口（推荐）
```java
class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("线程执行: " + Thread.currentThread().getName());
    }
}

// 使用
Thread thread = new Thread(new MyRunnable());
thread.start();

// 或使用Lambda表达式
Thread thread2 = new Thread(() -> {
    System.out.println("Lambda线程执行");
});
thread2.start();
```

## 3. 实现Callable接口（可返回结果）
```java
class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        return "线程执行结果";
    }
}

// 使用
ExecutorService executor = Executors.newSingleThreadExecutor();
Future<String> future = executor.submit(new MyCallable());
String result = future.get(); // 获取返回值
executor.shutdown();
```

## 4. 使用线程池（生产环境推荐）
```java
// 创建线程池
ExecutorService executor = Executors.newFixedThreadPool(5);

// 提交任务
for (int i = 0; i < 10; i++) {
    executor.execute(() -> {
        System.out.println("线程池任务执行: " + Thread.currentThread().getName());
    });
}

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

## 5. 使用CompletableFuture（Java 8+）
```java
// 异步执行
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    return "异步任务结果";
});

// 处理结果
future.thenAccept(result -> System.out.println("收到结果: " + result));
```

## 6. Timer和TimerTask
```java
Timer timer = new Timer();
timer.schedule(new TimerTask() {
    @Override
    public void run() {
        System.out.println("定时任务执行");
    }
}, 1000, 2000); // 延迟1秒，每2秒执行一次
```

## 总结对比

| 方法 | 优点 | 缺点 | 适用场景 |
|------|------|------|----------|
| 继承Thread | 简单直接 | 不能继承其他类 | 简单任务 |
| 实现Runnable | 灵活，可继承其他类 | 无返回值 | 大多数场景 |
| 实现Callable | 有返回值，可抛异常 | 使用相对复杂 | 需要返回结果的场景 |
| 线程池 | 资源管理，性能优化 | 配置复杂 | 生产环境，高并发 |
| CompletableFuture | 异步编程，链式调用 | Java 8+ | 复杂的异步任务 |

## 最佳实践建议

1. **优先使用Runnable接口** - 更灵活，符合面向接口编程
2. **生产环境使用线程池** - 避免频繁创建销毁线程的开销
3. **使用Callable获取返回值** - 当需要任务执行结果时
4. **Java 8+推荐CompletableFuture** - 提供更强大的异步编程能力
5. **注意线程安全** - 合理使用同步机制

最常用的组合是：**Runnable接口 + 线程池**，这种组合既灵活又高效。