java多线程怎么实践

下面从基础概念 → 常见用法 → 实践示例 → 注意事项，系统地讲一下 Java 多线程的实践方式。

一、Java 多线程的几种实现方式

1️⃣ 继承 Thread

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Thread running");
    }
}

public class Test {
    public static void main(String[] args) {
        new MyThread().start();
    }
}

✅ 简单
❌ 不支持多继承，不推荐日常使用

2️⃣ 实现 Runnable（推荐）

class MyTask implements Runnable {
    @Override
    public void run() {
        System.out.println("Runnable running");
    }
}

public class Test {
    public static void main(String[] args) {
        new Thread(new MyTask()).start();
    }
}

✅ 更灵活（可配合线程池）

3️⃣ 实现 Callable + Future（有返回值）

import java.util.concurrent.*;

public class Test {
    public static void main(String[] args) throws Exception {
        ExecutorService pool = Executors.newSingleThreadExecutor();
        Future<String> future = pool.submit(() -> "result");

        System.out.println(future.get());
        pool.shutdown();
    }
}

✅ 能返回结果 / 抛异常

二、线程池（最重要 ✅）

不要手动频繁 new Thread，应使用线程池。

ExecutorService pool = Executors.newFixedThreadPool(10);

pool.execute(() -> {
    System.out.println("task");
});

pool.shutdown();

推荐手动创建（更可控）：

new ThreadPoolExecutor(
     corePoolSize,
     maximumPoolSize,
     keepAliveTime,
     TimeUnit.SECONDS,
     new LinkedBlockingQueue<>()
);

三、线程同步（线程安全）

1️⃣ synchronized

public synchronized void add() {
    count++;
}

或代码块：

synchronized (this) {
    count++;
}

2️⃣ Lock

Lock lock = new ReentrantLock();
lock.lock();
try {
    count++;
} finally {
    lock.unlock();
}

✅ 更灵活（可中断、超时）

3️⃣ 原子类（高性能）

AtomicInteger count = new AtomicInteger();
count.incrementAndGet();

四、线程间通信

wait / notify

synchronized (obj) {
    obj.wait();
    obj.notify();
}

更高级

• CountDownLatch
• CyclicBarrier
• Semaphore
• BlockingQueue

五、常见实践场景

✅ 并行处理任务

List<Future<?>> futures = new ArrayList<>();
for (int i = 0; i < 10; i++) {
    futures.add(pool.submit(task));
}

✅ 生产者消费者

BlockingQueue<Integer> queue = new LinkedBlockingQueue<>();

六、常见坑 ⚠️

1. 死锁
   • 多把锁顺序不一致
2. 线程泄露
   • 忘记 shutdown()
3. 共享变量未同步
4. 滥用 synchronized
5. CPU 空转（while(true)）

七、推荐学习路线

1. Thread / Runnable
2. synchronized / volatile
3. 线程池
4. Lock & 并发工具类
5. JUC（java.util.concurrent）

如果你愿意，我可以：

• 给你一个完整多线程示例项目
• 讲面试常问多线程问题
• 或针对你当前的业务场景设计方案

你现在是学习阶段还是项目实战？