Java多线程并发编程常见错误实例

原创布满荆棘的人生 2024-10-21 17:33 60阅读 0赞

在Java多线程并发编程中，常见的错误包括：

1. **死锁**：多个线程相互等待对方释放资源时形成的僵局。

```java
// 死锁示例
class DeadlockResource {
    int resource;
}

class ThreadA extends Thread {
    DeadlockResource res;

ThreadA(DeadlockResource res) {
        this.res = res;
    }

public void run() {
        while (true) { // 无限循环，资源等待释放
            if (res.resource > 0) { // 判断资源是否可用
                System.out.println("Thread A released resource");
                break; // 资源可用，退出循环
            }
            Thread.sleep(100); // 暂停100毫秒
        }
    }
}

class ThreadB extends Thread {
    DeadlockResource res;

ThreadB(DeadlockResource res) {
        this.res = res;
    }

public void run() {
        while (true) { // 无限循环，资源等待释放
            if (res.resource > 0) { // 判断资源是否可用
                System.out.println("Thread B released resource");
                break; // 资源可用，退出循环
            }
            Thread.sleep(100); // 暂停100毫秒
        }
    }
}

public class Main {
    public static void main(String[] args) {
        DeadlockResource res = new DeadlockResource();
        res.resource = 5; // 分配资源

ThreadA threadA = new ThreadA(res);
        ThreadB threadB = new ThreadB(res);

threadA.start();
        threadB.start();

// 这里会陷入死锁，因为两个线程都等待对方释放资源
    }
}
```

2. **竞态条件**：多个线程同时访问和修改共享数据时可能出现的问题。

```java
// 竞态条件示例
class SharedCounter {
    int count = 0;

synchronized void increment() {
        count++;
        notifyAll(); // 通知所有等待的线程
    }

synchronized void decrement() {
        if (count > 0) { // 如果计数大于0，才允许减少
            count--;
            if (count == 0) { // 当计数变为0时，进入阻塞状态
                try {
                    wait(); // 等待被通知或者超时后再次获取锁
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

public int getCount() {
        synchronized (this) {
            return count;
        }
    }
}

public class Main {
    public static void main(String[] args) {
        SharedCounter counter = new SharedCounter();

// 创建线程1，增加计数
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 5; i++) { // 进行5次循环，每次尝试增加计数
                try {
                    counter.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }));

// 创建线程2，尝试减少计数
        Thread thread2 = new Thread(() -> {
            while (true) { // 无限循环，直到计数器变为0
                try {
                    if (counter.getCount() > 0) { // 如果计数大于0，才允许减少
                        counter.decrement();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }));

thread1.start(); // 启动线程1
        thread2.start(); // 启动线程2

try {
            thread1.join(); // 等待线程1执行完毕
            thread2.join(); // 等待线程2执行完毕
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

System.out.println("Final count: " + counter.getCount()); // 输出最终计数结果
    }
}
```

以上示例中，线程1试图增加计数器的值，线程2则试图减少计数器。由于两个线程共享同一个计数器，所以可能会出现竞态条件，导致结果不正确。