Java多线程常见问题实例解析

原创 Myth丶恋晨 2024-10-21 23:03 70阅读 0赞

在Java多线程编程中，常见的问题包括但不限于以下几种：

1. **死锁**：两个或多个线程互相等待对方释放资源而造成的一种僵局。

实例：
```java
// 线程A
public class ThreadA extends Thread {
    Object lockA = new Object();

@Override
    public void run() {
        synchronized (lockA) { // 假设锁A是线程B的条件
            try {
                lockA.wait(); // A释放锁，进入wait状态
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

// 获取锁A后执行任务
        System.out.println("Thread A is executing task after acquiring lock A.");

// 重新获取锁B并释放锁A
        synchronized (lockA) {
            lockA.notifyAll(); // B通知所有等待锁A的线程
            try {
                lockA.wait(); // A再次进入wait状态，让位给B
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

// 线程B
public class ThreadB extends Thread {
    Object lockB = new Object();

@Override
    public void run() {
        synchronized (lockB) { // 假设锁B是线程A的条件
            try {
                lockB.wait(); // B释放锁，进入wait状态
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

// 获取锁B后执行任务
        System.out.println("Thread B is executing task after acquiring lock B.");

// 重新获取锁A并释放锁B
        synchronized (lockB) {
            lockB.notifyAll(); // A通知所有等待锁B的线程
            try {
                lockB.wait(); // B再次进入wait状态，让位给A
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
```
2. **资源争抢**：多个线程同时访问有限资源（如文件、数据库连接等）。

实例：
```java
// 线程1
public class Thread1 extends Thread {
    private Object lock = new Object();

@Override
    public void run() {
        synchronized (lock) { // 获取锁
            try {
                // 执行任务，假设需要写入资源
                System.out.println("Thread 1 is executing task.");
                
                // 因资源有限，这里模拟等待锁释放
                lock.wait(); // 让位给其他线程
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

// 如果任务完成，这里手动唤醒锁
        synchronized (lock) {
            lock.notifyAll(); // 唤醒所有等待锁的线程
        }
    }
}

// 线程2
public class Thread2 extends Thread {
    private Object lock = new Object();

@Override
    public void run() {
        synchronized (lock) { // 获取锁
            try {
                // 执行任务，假设需要读取资源
                System.out.println("Thread 2 is executing task.");
                
                // 因资源有限，这里模拟等待锁释放
                lock.wait(); // 让位给其他线程
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

// 如果任务完成，这里手动唤醒锁
        synchronized (lock) {
            lock.notifyAll(); // 唤醒所有等待锁的线程
        }
    }
}
```
3. **死循环**：多处可能导致无限循环的代码。

实例：
```java
public class InfiniteLoopExample {
    public void infiniteLoop() {
        while (true) { // 无限循环条件
            System.out.println("This is an infinite loop.");
            
            // 这里可能会导致无限等待，实际上需要睡眠或者处理其他任务
            Thread.sleep(1000); // 假设这需要1秒的睡眠时间
        }
    }

public static void main(String[] args) {
        new InfiniteLoopExample().infiniteLoop();
    }
}
```
以上例子展示了多线程编程中常见的问题及其解决方案。