1. Java多线程编程基础解析
多线程是Java编程中一个非常重要的概念，它允许程序同时执行多个任务，提高了程序的执行效率和资源利用率。在Java中，每个线程都是一个独立的执行路径，它们共享进程的内存空间，但拥有各自的栈空间。
注意：虽然多线程能提高程序性能，但不当使用会导致线程安全问题、死锁等问题，需要谨慎处理。
1.1 线程的基本概念
在操作系统中，线程是比进程更小的执行单位。一个进程可以包含多个线程，这些线程共享进程的资源（如内存、文件描述符等），但每个线程有自己的程序计数器、栈和局部变量。
Java中的线程有以下特点：
- 轻量级：创建和销毁线程的开销比进程小
- 共享内存：同一进程内的线程共享内存空间
- 独立执行：每个线程有自己的执行路径
- 抢占式调度：线程调度由JVM和操作系统决定
2. 线程的创建方式
Java提供了两种主要的创建线程的方式，每种方式都有其适用场景和优缺点。
2.1 继承Thread类
这是最基本的创建线程方式，通过继承Thread类并重写run()方法来实现：
java复制class MyThread extends Thread {
@Override
public void run() {
// 线程执行的代码
System.out.println("线程运行中...");
}
}
public class Main {
public static void main(String[] args) {
MyThread thread = new MyThread();
thread.start(); // 启动线程
}
}
关键点：必须调用start()方法而不是直接调用run()方法，start()会创建新的执行线程，而run()只是普通方法调用。
2.1.1 继承方式的局限性
这种方式的缺点是Java只支持单继承，如果一个类已经继承了其他类，就无法再继承Thread类。这时就需要使用第二种方式。
2.2 实现Runnable接口
更推荐的方式是实现Runnable接口，它更灵活且符合面向对象设计原则：
java复制class MyRunnable implements Runnable {
@Override
public void run() {
// 线程执行的代码
System.out.println("实现Runnable的线程运行中...");
}
}
public class Main {
public static void main(String[] args) {
Thread thread = new Thread(new MyRunnable());
thread.start();
}
}
2.2.1 静态代理模式
Thread类实际上采用了静态代理模式，它内部持有一个Runnable对象，当调用start()方法时，会创建新线程并调用Runnable对象的run()方法。
3. 线程的生命周期与状态管理
3.1 线程的生命周期
Java线程有以下几种状态：
- NEW：新建状态，线程被创建但尚未启动
- RUNNABLE：可运行状态，线程正在JVM中执行或等待操作系统资源
- BLOCKED：阻塞状态，线程等待获取监视器锁
- WAITING：等待状态，线程无限期等待其他线程执行特定操作
- TIMED_WAITING：计时等待状态，线程在指定时间内等待
- TERMINATED：终止状态，线程已完成执行
可以通过Thread.getState()方法获取线程当前状态。
3.2 线程常用方法
- start()：启动线程
- run()：线程执行体
- sleep(long millis)：使当前线程休眠指定毫秒数
- join()：等待该线程终止
- interrupt()：中断线程
- isAlive()：测试线程是否处于活动状态
- setPriority(int newPriority)：更改线程优先级
- yield()：暂停当前线程，让出CPU资源
注意事项：直接调用interrupt()不会立即停止线程，它只是设置中断标志，线程需要检查这个标志并决定如何响应。
4. 线程同步与锁机制
4.1 同步的必要性
当多个线程访问共享资源时，可能会产生竞态条件（Race Condition），导致数据不一致。例如：
java复制class Counter {
private int count = 0;
public void increment() {
count++;
}
public int getCount() {
return count;
}
}
如果多个线程同时调用increment()，count的值可能不会按预期增加，因为count++不是原子操作。
4.2 synchronized关键字
Java提供了synchronized关键字来实现同步：
java复制class SafeCounter {
private int count = 0;
public synchronized void increment() {
count++;
}
public synchronized int getCount() {
return count;
}
}
synchronized可以用在：
- 实例方法上：锁是当前实例对象
- 静态方法上：锁是当前类的Class对象
- 代码块上：可以指定锁对象
4.3 死锁问题
死锁是指两个或多个线程互相持有对方需要的资源，导致所有线程都无法继续执行。例如：
java复制// 线程1
synchronized(resourceA) {
synchronized(resourceB) {
// 操作资源A和B
}
}
// 线程2
synchronized(resourceB) {
synchronized(resourceA) {
// 操作资源A和B
}
}
避免死锁的策略：
- 按固定顺序获取锁
- 使用tryLock()尝试获取锁
- 设置锁超时时间
- 避免嵌套锁
5. 实战案例：坦克大战游戏的多线程实现
5.1 游戏架构设计
坦克大战游戏涉及多个并发实体：
- 玩家坦克：由玩家控制
- 敌人坦克：AI控制，自动移动和射击
- 子弹：由坦克发射，独立移动
每个实体都需要独立的线程来控制其行为。
5.2 关键代码实现
5.2.1 坦克基类
java复制public class Tank {
private int x;
private int y;
private int direction = 2; // 默认向下
boolean isLive = true;
// 移动方法
public void moveup() { this.y -= 1; }
public void movedown() { this.y += 1; }
public void moveleft() { this.x -= 1; }
public void moveright() { this.x += 1; }
// getter和setter方法
// ...
}
5.2.2 玩家坦克类
java复制public class MyTank extends Tank {
Vector<Shot> shots = new Vector<>();
public void shotEnemyTank() {
if(shots.size() == 5) return; // 限制子弹数量
Shot shot = null;
switch(getDirection()) {
case 0: shot = new Shot(getX() + 20, getY(), 0); break;
case 1: shot = new Shot(getX() + 60, getY() + 20, 1); break;
case 2: shot = new Shot(getX() + 20, getY() + 60, 2); break;
case 3: shot = new Shot(getX(), getY() + 20, 3); break;
}
shots.add(shot);
new Thread(shot).start(); // 启动子弹线程
}
}
5.2.3 子弹类
java复制public class Shot implements Runnable {
int x, y;
int direction;
int speed = 5;
boolean isLive = true;
@Override
public void run() {
while(true) {
try {
Thread.sleep(50); // 控制移动速度
} catch (InterruptedException e) {
e.printStackTrace();
}
// 边界检查
if(!(x >= 0 && x <= 1000 && y >= 0 && y <= 750)) {
isLive = false;
break;
}
// 根据方向移动
switch(direction) {
case 0: y -= speed; break; // 上
case 1: x += speed; break; // 右
case 2: y += speed; break; // 下
case 3: x -= speed; break; // 左
}
}
}
}
5.3 碰撞检测实现
java复制public void hitTank(Shot shot, Tank tank) {
switch(tank.getDirection()) {
case 0: case 2: // 上下方向
if(shot.x > tank.getX() && shot.x < tank.getX() + 40
&& shot.y > tank.getY() && shot.y < tank.getY() + 60) {
shot.isLive = false;
tank.isLive = false;
enemyTanks.remove(tank);
}
break;
case 1: case 3: // 左右方向
if(shot.x > tank.getX() && shot.x < tank.getX() + 60
&& shot.y > tank.getY() && shot.y < tank.getY() + 40) {
shot.isLive = false;
tank.isLive = false;
enemyTanks.remove(tank);
}
break;
}
}
6. 多线程编程的注意事项
6.1 线程安全最佳实践
- 尽量使用局部变量而非共享变量
- 使用不可变对象（Immutable Objects）
- 使用线程安全的集合类（如ConcurrentHashMap）
- 合理使用同步机制，避免过度同步
- 考虑使用更高层次的并发工具（如Executor框架）
6.2 性能考量
- 线程创建和销毁有开销，考虑使用线程池
- 同步会带来性能损耗，尽量减少同步范围
- 避免不必要的线程间通信
- 合理设置线程优先级
6.3 常见问题排查
- 死锁：使用jstack工具分析线程转储
- 内存泄漏：注意线程生命周期管理
- 性能瓶颈：使用性能分析工具定位
- 竞态条件：仔细检查共享资源的访问
7. 高级主题与扩展
7.1 Java并发包（java.util.concurrent）
Java提供了丰富的并发工具：
- Executor框架：管理线程池
- Future和Callable：支持返回结果的异步任务
- Lock接口：更灵活的锁机制
- 原子变量类：无锁线程安全编程
- 并发集合：线程安全的集合实现
7.2 线程池的使用
java复制ExecutorService executor = Executors.newFixedThreadPool(5);
for (int i = 0; i < 10; i++) {
Runnable worker = new WorkerThread("" + i);
executor.execute(worker);
}
executor.shutdown();
线程池的优点：
- 降低资源消耗：重复利用已创建的线程
- 提高响应速度：任务到达时线程已存在
- 提高线程的可管理性：可以统一分配、调优和监控
7.3 异步编程与CompletableFuture
Java 8引入了CompletableFuture，简化了异步编程：
java复制CompletableFuture.supplyAsync(() -> {
// 异步执行的任务
return "结果";
}).thenAccept(result -> {
// 处理结果
System.out.println(result);
});
8. 实战经验分享
在实际开发中，处理多线程问题时我总结了一些经验：
-
优先考虑线程安全的设计：与其后期添加同步，不如从一开始就设计线程安全的类。
-
合理控制线程数量：过多的线程会导致上下文切换开销增大，反而降低性能。
-
避免在同步块中执行耗时操作：这会严重降低系统的吞吐量。
-
使用适当的工具进行测试：多线程程序的测试比较困难，可以使用CountDownLatch等工具辅助测试。
-
日志记录要线程安全：确保日志记录器是线程安全的，或者在每个线程中使用独立的日志记录器。
-
异常处理要完善：线程中的未捕获异常会导致线程终止，但可能不会影响整个程序。
-
资源清理要彻底：确保线程结束时释放所有占用的资源，特别是数据库连接、文件句柄等。
-
考虑使用更高层次的抽象：如Akka、RxJava等框架，它们提供了更高级的并发模型。